diff --git a/install_requirements.sh b/install_requirements.sh
index 74db1cb342862d08653bab4ac81edbd4f63d4e8f..c59ea7f13909c789fef587192a56876187eb4195 100755
--- a/install_requirements.sh
+++ b/install_requirements.sh
@@ -24,6 +24,22 @@ ALL_COMPONENTS="${ALL_COMPONENTS} dbscanserving opticalattackmitigator opticalat
ALL_COMPONENTS="${ALL_COMPONENTS} l3_attackmitigator l3_centralizedattackdetector l3_distributedattackdetector"
TFS_COMPONENTS=${TFS_COMPONENTS:-$ALL_COMPONENTS}
+# Some components require libyang built from source code
+# - Ref: https://github.com/CESNET/libyang
+# - Ref: https://github.com/CESNET/libyang-python/
+echo "Installing libyang..."
+sudo apt-get --yes --quiet --quiet update
+sudo apt-get --yes --quiet --quiet install build-essential cmake libpcre2-dev python3-dev python3-cffi
+mkdir libyang
+git clone https://github.com/CESNET/libyang.git libyang
+mkdir libyang/build
+cd libyang/build
+cmake -D CMAKE_BUILD_TYPE:String="Release" ..
+make
+sudo make install
+sudo ldconfig
+cd ../..
+
echo "Updating PIP, SetupTools and Wheel..."
pip install --upgrade pip # ensure next packages get the latest versions
pip install --upgrade setuptools wheel # bring basic tooling for other requirements
diff --git a/manifests/contextservice.yaml b/manifests/contextservice.yaml
index 96735bf5f89f682f31131c123ee9884a1becbfdb..df06c86b58849762277f5d99788e36b1933e9a69 100644
--- a/manifests/contextservice.yaml
+++ b/manifests/contextservice.yaml
@@ -41,6 +41,10 @@ spec:
value: "nats"
- name: LOG_LEVEL
value: "INFO"
+ - name: ALLOW_EXPLICIT_ADD_DEVICE_TO_TOPOLOGY
+ value: "FALSE"
+ - name: ALLOW_EXPLICIT_ADD_LINK_TO_TOPOLOGY
+ value: "FALSE"
envFrom:
- secretRef:
name: crdb-data
diff --git a/scripts/run_tests_locally-nbi-all.sh b/scripts/run_tests_locally-nbi-all.sh
new file mode 100755
index 0000000000000000000000000000000000000000..48961b0fe20ab4ac3658a6f35ce89ec659e52dc0
--- /dev/null
+++ b/scripts/run_tests_locally-nbi-all.sh
@@ -0,0 +1,35 @@
+#!/bin/bash
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+PROJECTDIR=`pwd`
+
+cd $PROJECTDIR/src
+RCFILE=$PROJECTDIR/coverage/.coveragerc
+
+# Run unitary tests and analyze coverage of code at same time
+# helpful pytest flags: --log-level=INFO -o log_cli=true --verbose --maxfail=1 --durations=0
+
+coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
+ nbi/tests/test_etsi_bwm.py
+
+coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
+ nbi/tests/test_ietf_l2vpn.py
+
+coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
+ nbi/tests/test_ietf_l3vpn.py
+
+coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
+ nbi/tests/test_ietf_network.py
diff --git a/scripts/run_tests_locally-nbi.sh b/scripts/run_tests_locally-nbi-etsi-bwm.sh
similarity index 87%
rename from scripts/run_tests_locally-nbi.sh
rename to scripts/run_tests_locally-nbi-etsi-bwm.sh
index 1be0451588195cf6d97c7742e7d2c7f29e08441a..dc5f79ffa96c853671b5a4cc41d2c69fbc89f350 100755
--- a/scripts/run_tests_locally-nbi.sh
+++ b/scripts/run_tests_locally-nbi-etsi-bwm.sh
@@ -20,5 +20,6 @@ cd $PROJECTDIR/src
RCFILE=$PROJECTDIR/coverage/.coveragerc
# Run unitary tests and analyze coverage of code at same time
+# helpful pytest flags: --log-level=INFO -o log_cli=true --verbose --maxfail=1 --durations=0
coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
- nbi/tests/test_unitary.py
+ nbi/tests/test_etsi_bwm.py
diff --git a/scripts/run_tests_locally-nbi-ietf-l2vpn.sh b/scripts/run_tests_locally-nbi-ietf-l2vpn.sh
new file mode 100755
index 0000000000000000000000000000000000000000..595606d1fbeeae105748d75e326427e47277b955
--- /dev/null
+++ b/scripts/run_tests_locally-nbi-ietf-l2vpn.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+PROJECTDIR=`pwd`
+
+cd $PROJECTDIR/src
+RCFILE=$PROJECTDIR/coverage/.coveragerc
+
+# Run unitary tests and analyze coverage of code at same time
+# helpful pytest flags: --log-level=INFO -o log_cli=true --verbose --maxfail=1 --durations=0
+coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
+ nbi/tests/test_ietf_l2vpn.py
diff --git a/scripts/run_tests_locally-nbi-ietf-l3vpn.sh b/scripts/run_tests_locally-nbi-ietf-l3vpn.sh
new file mode 100755
index 0000000000000000000000000000000000000000..0bd133e16caac438c8da1a5795fce89e99230c9a
--- /dev/null
+++ b/scripts/run_tests_locally-nbi-ietf-l3vpn.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+PROJECTDIR=`pwd`
+
+cd $PROJECTDIR/src
+RCFILE=$PROJECTDIR/coverage/.coveragerc
+
+# Run unitary tests and analyze coverage of code at same time
+# helpful pytest flags: --log-level=INFO -o log_cli=true --verbose --maxfail=1 --durations=0
+coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
+ nbi/tests/test_ietf_l3vpn.py
diff --git a/scripts/run_tests_locally-nbi-ietf-network.sh b/scripts/run_tests_locally-nbi-ietf-network.sh
new file mode 100755
index 0000000000000000000000000000000000000000..a9fa030878e68789ffbfbe57eed76b933f897b5b
--- /dev/null
+++ b/scripts/run_tests_locally-nbi-ietf-network.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+PROJECTDIR=`pwd`
+
+cd $PROJECTDIR/src
+RCFILE=$PROJECTDIR/coverage/.coveragerc
+
+# Run unitary tests and analyze coverage of code at same time
+# helpful pytest flags: --log-level=INFO -o log_cli=true --verbose --maxfail=1 --durations=0
+coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
+ nbi/tests/test_ietf_network.py
diff --git a/src/common/DeviceTypes.py b/src/common/DeviceTypes.py
index bb8948585f163aeb84ee758b8581bc6509d29799..f88f931d4c465349a37a92b5891fd0acd8fe6a48 100644
--- a/src/common/DeviceTypes.py
+++ b/src/common/DeviceTypes.py
@@ -20,6 +20,7 @@ class DeviceTypeEnum(Enum):
NETWORK = 'network'
# Emulated device types
+ EMULATED_CLIENT = 'emu-client'
EMULATED_DATACENTER = 'emu-datacenter'
EMULATED_MICROWAVE_RADIO_SYSTEM = 'emu-microwave-radio-system'
EMULATED_OPEN_LINE_SYSTEM = 'emu-open-line-system'
@@ -33,6 +34,7 @@ class DeviceTypeEnum(Enum):
EMULATED_XR_CONSTELLATION = 'emu-xr-constellation'
# Real device types
+ CLIENT = 'client'
DATACENTER = 'datacenter'
MICROWAVE_RADIO_SYSTEM = 'microwave-radio-system'
OPEN_LINE_SYSTEM = 'open-line-system'
diff --git a/src/common/tests/InMemoryObjectDatabase.py b/src/common/tests/InMemoryObjectDatabase.py
index 21697a4355795775cc25112671c4e436fbbecb8c..f5f98872a72efef1d4e01966efbac98a38e6a8e3 100644
--- a/src/common/tests/InMemoryObjectDatabase.py
+++ b/src/common/tests/InMemoryObjectDatabase.py
@@ -37,7 +37,9 @@ class InMemoryObjectDatabase:
LOGGER.debug('[get_entry] BEFORE database={:s}'.format(str(self._database)))
container = self._get_container(container_name)
if entry_uuid not in container:
- context.abort(grpc.StatusCode.NOT_FOUND, str('{:s}({:s}) not found'.format(container_name, entry_uuid)))
+ MSG = '{:s}({:s}) not found; available({:s})'
+ msg = str(MSG.format(container_name, entry_uuid, str(container.keys())))
+ context.abort(grpc.StatusCode.NOT_FOUND, msg)
return container[entry_uuid]
def set_entry(self, container_name : str, entry_uuid : str, entry : Any) -> Any:
diff --git a/src/common/tests/MockServicerImpl_Context.py b/src/common/tests/MockServicerImpl_Context.py
index 55f87b7b0c03a7ae563dc10bd5e4964a07317c21..98a216850a757e0c21c44d2e295cb4b93c538e05 100644
--- a/src/common/tests/MockServicerImpl_Context.py
+++ b/src/common/tests/MockServicerImpl_Context.py
@@ -26,6 +26,8 @@ from common.proto.context_pb2 import (
Topology, TopologyDetails, TopologyEvent, TopologyId, TopologyIdList, TopologyList)
from common.proto.context_pb2_grpc import ContextServiceServicer
from common.tools.grpc.Tools import grpc_message_to_json, grpc_message_to_json_string
+from common.tools.object_factory.Device import json_device_id
+from common.tools.object_factory.Link import json_link_id
from .InMemoryObjectDatabase import InMemoryObjectDatabase
from .MockMessageBroker import (
TOPIC_CONNECTION, TOPIC_CONTEXT, TOPIC_DEVICE, TOPIC_LINK, TOPIC_SERVICE, TOPIC_SLICE, TOPIC_TOPOLOGY,
@@ -143,17 +145,60 @@ class MockServicerImpl_Context(ContextServiceServicer):
def SetTopology(self, request: Topology, context : grpc.ServicerContext) -> TopologyId:
LOGGER.debug('[SetTopology] request={:s}'.format(grpc_message_to_json_string(request)))
- container_name = 'topology[{:s}]'.format(str(request.topology_id.context_id.context_uuid.uuid))
+ context_uuid = str(request.topology_id.context_id.context_uuid.uuid)
+ container_name = 'topology[{:s}]'.format(context_uuid)
topology_uuid = request.topology_id.topology_uuid.uuid
+
+ if self.obj_db.has_entry(container_name, topology_uuid):
+ # merge device_ids and link_ids from database and request, and update request
+ db_topology = self.obj_db.get_entry(container_name, topology_uuid, context)
+
+ device_uuids = set()
+ for device_id in request.device_ids: device_uuids.add(device_id.device_uuid.uuid)
+ for device_id in db_topology.device_ids: device_uuids.add(device_id.device_uuid.uuid)
+
+ link_uuids = set()
+ for link_id in request.link_ids: link_uuids.add(link_id.link_uuid.uuid)
+ for link_id in db_topology.link_ids: link_uuids.add(link_id.link_uuid.uuid)
+
+ rw_request = Topology()
+ rw_request.CopyFrom(request)
+
+ del rw_request.device_ids[:]
+ for device_uuid in sorted(device_uuids):
+ rw_request.device_ids.append(DeviceId(**json_device_id(device_uuid)))
+
+ del rw_request.link_ids[:]
+ for link_uuid in sorted(link_uuids):
+ rw_request.link_ids.append(LinkId(**json_link_id(link_uuid)))
+
+ request = rw_request
+
reply,_ = self._set(request, container_name, topology_uuid, 'topology_id', TOPIC_TOPOLOGY)
+
+ context_ = self.obj_db.get_entry('context', context_uuid, context)
+ for _topology_id in context_.topology_ids:
+ if _topology_id.topology_uuid.uuid == topology_uuid: break
+ else:
+ # topology not found, add it
+ context_.topology_ids.add().topology_uuid.uuid = topology_uuid
+
LOGGER.debug('[SetTopology] reply={:s}'.format(grpc_message_to_json_string(reply)))
return reply
def RemoveTopology(self, request: TopologyId, context : grpc.ServicerContext) -> Empty:
LOGGER.debug('[RemoveTopology] request={:s}'.format(grpc_message_to_json_string(request)))
- container_name = 'topology[{:s}]'.format(str(request.context_id.context_uuid.uuid))
+ context_uuid = str(request.context_id.context_uuid.uuid)
+ container_name = 'topology[{:s}]'.format(context_uuid)
topology_uuid = request.topology_uuid.uuid
reply = self._del(request, container_name, topology_uuid, 'topology_id', TOPIC_TOPOLOGY, context)
+
+ context_ = self.obj_db.get_entry('context', context_uuid, context)
+ for _topology_id in context_.topology_ids:
+ if _topology_id.topology_uuid.uuid == topology_uuid:
+ context_.topology_ids.remove(_topology_id)
+ break
+
LOGGER.debug('[RemoveTopology] reply={:s}'.format(grpc_message_to_json_string(reply)))
return reply
@@ -368,17 +413,34 @@ class MockServicerImpl_Context(ContextServiceServicer):
def SetSlice(self, request: Slice, context : grpc.ServicerContext) -> SliceId:
LOGGER.debug('[SetSlice] request={:s}'.format(grpc_message_to_json_string(request)))
- container_name = 'slice[{:s}]'.format(str(request.slice_id.context_id.context_uuid.uuid))
+ context_uuid = str(request.slice_id.context_id.context_uuid.uuid)
+ container_name = 'slice[{:s}]'.format(context_uuid)
slice_uuid = request.slice_id.slice_uuid.uuid
reply,_ = self._set(request, container_name, slice_uuid, 'slice_id', TOPIC_SLICE)
+
+ context_ = self.obj_db.get_entry('context', context_uuid, context)
+ for _slice_id in context_.slice_ids:
+ if _slice_id.slice_uuid.uuid == slice_uuid: break
+ else:
+ # slice not found, add it
+ context_.slice_ids.add().slice_uuid.uuid = slice_uuid
+
LOGGER.debug('[SetSlice] reply={:s}'.format(grpc_message_to_json_string(reply)))
return reply
def RemoveSlice(self, request: SliceId, context : grpc.ServicerContext) -> Empty:
LOGGER.debug('[RemoveSlice] request={:s}'.format(grpc_message_to_json_string(request)))
- container_name = 'slice[{:s}]'.format(str(request.context_id.context_uuid.uuid))
+ context_uuid = str(request.context_id.context_uuid.uuid)
+ container_name = 'slice[{:s}]'.format(context_uuid)
slice_uuid = request.slice_uuid.uuid
reply = self._del(request, container_name, slice_uuid, 'slice_id', TOPIC_SLICE, context)
+
+ context_ = self.obj_db.get_entry('context', context_uuid, context)
+ for _slice_id in context_.slice_ids:
+ if _slice_id.slice_uuid.uuid == slice_uuid:
+ context_.slice_ids.remove(_slice_id)
+ break
+
LOGGER.debug('[RemoveSlice] reply={:s}'.format(grpc_message_to_json_string(reply)))
return reply
@@ -443,17 +505,34 @@ class MockServicerImpl_Context(ContextServiceServicer):
def SetService(self, request: Service, context : grpc.ServicerContext) -> ServiceId:
LOGGER.debug('[SetService] request={:s}'.format(grpc_message_to_json_string(request)))
- container_name = 'service[{:s}]'.format(str(request.service_id.context_id.context_uuid.uuid))
+ context_uuid = str(request.service_id.context_id.context_uuid.uuid)
+ container_name = 'service[{:s}]'.format(context_uuid)
service_uuid = request.service_id.service_uuid.uuid
reply,_ = self._set(request, container_name, service_uuid, 'service_id', TOPIC_SERVICE)
+
+ context_ = self.obj_db.get_entry('context', context_uuid, context)
+ for _service_id in context_.service_ids:
+ if _service_id.service_uuid.uuid == service_uuid: break
+ else:
+ # service not found, add it
+ context_.service_ids.add().service_uuid.uuid = service_uuid
+
LOGGER.debug('[SetService] reply={:s}'.format(grpc_message_to_json_string(reply)))
return reply
def RemoveService(self, request: ServiceId, context : grpc.ServicerContext) -> Empty:
LOGGER.debug('[RemoveService] request={:s}'.format(grpc_message_to_json_string(request)))
- container_name = 'service[{:s}]'.format(str(request.context_id.context_uuid.uuid))
+ context_uuid = str(request.context_id.context_uuid.uuid)
+ container_name = 'service[{:s}]'.format(context_uuid)
service_uuid = request.service_uuid.uuid
reply = self._del(request, container_name, service_uuid, 'service_id', TOPIC_SERVICE, context)
+
+ context_ = self.obj_db.get_entry('context', context_uuid, context)
+ for _service_id in context_.service_ids:
+ if _service_id.service_uuid.uuid == service_uuid:
+ context_.service_ids.remove(_service_id)
+ break
+
LOGGER.debug('[RemoveService] reply={:s}'.format(grpc_message_to_json_string(reply)))
return reply
diff --git a/src/common/tools/context_queries/Topology.py b/src/common/tools/context_queries/Topology.py
index caf03ed0eb5271aa6e00a2c107a06f9e496d37dc..c90d59105ae6b0805a73e9a53c664e063703f73d 100644
--- a/src/common/tools/context_queries/Topology.py
+++ b/src/common/tools/context_queries/Topology.py
@@ -65,7 +65,7 @@ def get_topology(
def get_topology_details(
context_client : ContextClient, topology_uuid : str, context_uuid : str = DEFAULT_CONTEXT_NAME,
rw_copy : bool = False
- ) -> Optional[Topology]:
+ ) -> Optional[TopologyDetails]:
try:
# pylint: disable=no-member
topology_id = TopologyId()
diff --git a/src/common/tools/descriptor/Loader.py b/src/common/tools/descriptor/Loader.py
index 916a73d300011c62fc008fc7437df8a71f6a9838..c5468c19ccc063387460ed7f7b28ee70c5f1d907 100644
--- a/src/common/tools/descriptor/Loader.py
+++ b/src/common/tools/descriptor/Loader.py
@@ -240,11 +240,16 @@ class DescriptorLoader:
self._process_descr('slice', 'add', self.__ctx_cli.SetSlice, Slice, self.__slices )
self._process_descr('connection', 'add', self.__ctx_cli.SetConnection, Connection, self.__connections )
- # Update context and topology is useless:
- # - devices and links are assigned to topologies automatically by Context component
- # - topologies, services, and slices are assigned to contexts automatically by Context component
+ # By default the Context component automatically assigns devices and links to topologies based on their
+ # endpoints, and assigns topologies, services, and slices to contexts based on their identifiers.
+
+ # The following statement is useless; up to now, any use case requires assigning a topology, service, or
+ # slice to a different context.
#self._process_descr('context', 'update', self.__ctx_cli.SetContext, Context, self.__contexts )
- #self._process_descr('topology', 'update', self.__ctx_cli.SetTopology, Topology, self.__topologies )
+
+ # In some cases, it might be needed to assign devices and links to multiple topologies; the
+ # following statement performs that assignment.
+ self._process_descr('topology', 'update', self.__ctx_cli.SetTopology, Topology, self.__topologies )
#self.__ctx_cli.close()
@@ -271,12 +276,17 @@ class DescriptorLoader:
self._process_descr('service', 'update', self.__svc_cli.UpdateService, Service, self.__services )
self._process_descr('slice', 'add', self.__slc_cli.CreateSlice, Slice, self.__slices_add )
self._process_descr('slice', 'update', self.__slc_cli.UpdateSlice, Slice, self.__slices )
-
- # Update context and topology is useless:
- # - devices and links are assigned to topologies automatically by Context component
- # - topologies, services, and slices are assigned to contexts automatically by Context component
+
+ # By default the Context component automatically assigns devices and links to topologies based on their
+ # endpoints, and assigns topologies, services, and slices to contexts based on their identifiers.
+
+ # The following statement is useless; up to now, any use case requires assigning a topology, service, or
+ # slice to a different context.
#self._process_descr('context', 'update', self.__ctx_cli.SetContext, Context, self.__contexts )
- #self._process_descr('topology', 'update', self.__ctx_cli.SetTopology, Topology, self.__topologies )
+
+ # In some cases, it might be needed to assign devices and links to multiple topologies; the
+ # following statement performs that assignment.
+ self._process_descr('topology', 'update', self.__ctx_cli.SetTopology, Topology, self.__topologies )
#self.__slc_cli.close()
#self.__svc_cli.close()
diff --git a/src/common/tools/descriptor/Tools.py b/src/common/tools/descriptor/Tools.py
index f03c635b802e5c003a6ea80af46ef740b97e500b..3126f2bcedb1aaeeda660674d41a249af03679fe 100644
--- a/src/common/tools/descriptor/Tools.py
+++ b/src/common/tools/descriptor/Tools.py
@@ -57,6 +57,8 @@ def format_custom_config_rules(config_rules : List[Dict]) -> List[Dict]:
if isinstance(custom_resource_value, (dict, list)):
custom_resource_value = json.dumps(custom_resource_value, sort_keys=True, indent=0)
config_rule['custom']['resource_value'] = custom_resource_value
+ elif not isinstance(custom_resource_value, str):
+ config_rule['custom']['resource_value'] = str(custom_resource_value)
return config_rules
def format_device_custom_config_rules(device : Dict) -> Dict:
diff --git a/src/common/tools/service/GenericRestServer.py b/src/common/tools/service/GenericRestServer.py
index 51d3f828fabea1a6d3b9a4d7da526750a50fcbf9..a5292e310abbf0335967cb94fdaed14c1ea3cd0e 100644
--- a/src/common/tools/service/GenericRestServer.py
+++ b/src/common/tools/service/GenericRestServer.py
@@ -37,7 +37,8 @@ class GenericRestServer(threading.Thread):
self.bind_port = bind_port
self.base_url = base_url
self.bind_address = get_http_bind_address() if bind_address is None else bind_address
- self.endpoint = 'http://{:s}:{:s}{:s}'.format(str(self.bind_address), str(self.bind_port), str(self.base_url))
+ self.endpoint = 'http://{:s}:{:s}'.format(str(self.bind_address), str(self.bind_port))
+ if self.base_url is not None: self.endpoint += str(self.base_url)
self.srv = None
self.ctx = None
self.app = Flask(__name__)
diff --git a/src/context/Config.py b/src/context/Config.py
index 1549d9811aa5d1c193a44ad45d0d7773236c0612..770b1f065b93718c5428e895fae948d8e6ee1466 100644
--- a/src/context/Config.py
+++ b/src/context/Config.py
@@ -12,3 +12,15 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+from common.Settings import get_setting
+
+TRUE_VALUES = {'Y', 'YES', 'T', 'TRUE', 'E', 'ENABLE', 'ENABLED'}
+def is_enabled(setting_name : str, default_value : bool) -> bool:
+ _is_enabled = get_setting(setting_name, default=None)
+ if _is_enabled is None: return default_value
+ str_is_enabled = str(_is_enabled).upper()
+ return str_is_enabled in TRUE_VALUES
+
+DEFAULT_VALUE = False
+ALLOW_EXPLICIT_ADD_DEVICE_TO_TOPOLOGY = is_enabled('ALLOW_EXPLICIT_ADD_DEVICE_TO_TOPOLOGY', DEFAULT_VALUE)
+ALLOW_EXPLICIT_ADD_LINK_TO_TOPOLOGY = is_enabled('ALLOW_EXPLICIT_ADD_LINK_TO_TOPOLOGY', DEFAULT_VALUE)
diff --git a/src/context/service/database/Link.py b/src/context/service/database/Link.py
index 4ca3cee68e45cc9b5a8f4e0d9f1b07a3ec39f268..e2060c4542bebad82b1ed83dbcce612114862ae7 100644
--- a/src/context/service/database/Link.py
+++ b/src/context/service/database/Link.py
@@ -102,14 +102,17 @@ def link_set(db_engine : Engine, messagebroker : MessageBroker, request : Link)
total_capacity_gbps, used_capacity_gbps = None, None
if request.HasField('attributes'):
attributes = request.attributes
+
# In proto3, HasField() does not work for scalar fields, using ListFields() instead.
attribute_names = set([field.name for field,_ in attributes.ListFields()])
+
if 'total_capacity_gbps' in attribute_names:
total_capacity_gbps = attributes.total_capacity_gbps
+
if 'used_capacity_gbps' in attribute_names:
used_capacity_gbps = attributes.used_capacity_gbps
- elif total_capacity_gbps is not None:
- used_capacity_gbps = total_capacity_gbps
+ else:
+ used_capacity_gbps = 0.0
link_data = [{
'link_uuid' : link_uuid,
diff --git a/src/context/service/database/Topology.py b/src/context/service/database/Topology.py
index 1f0fb6c0b3c400d58ea83bc857e97bc50a1324a3..e8f99415509ee16e359d4737a2f4f41fed7f09a8 100644
--- a/src/context/service/database/Topology.py
+++ b/src/context/service/database/Topology.py
@@ -17,17 +17,20 @@ from sqlalchemy.dialects.postgresql import insert
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, selectinload, sessionmaker
from sqlalchemy_cockroachdb import run_transaction
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Set
from common.proto.context_pb2 import (
ContextId, Empty, EventTypeEnum, Topology, TopologyDetails, TopologyId, TopologyIdList, TopologyList)
from common.message_broker.MessageBroker import MessageBroker
from common.method_wrappers.ServiceExceptions import NotFoundException
from common.tools.object_factory.Context import json_context_id
from common.tools.object_factory.Topology import json_topology_id
+from context.Config import ALLOW_EXPLICIT_ADD_DEVICE_TO_TOPOLOGY, ALLOW_EXPLICIT_ADD_LINK_TO_TOPOLOGY
from .models.DeviceModel import DeviceModel
from .models.LinkModel import LinkModel
from .models.TopologyModel import TopologyDeviceModel, TopologyLinkModel, TopologyModel
from .uuids.Context import context_get_uuid
+from .uuids.Device import device_get_uuid
+from .uuids.Link import link_get_uuid
from .uuids.Topology import topology_get_uuid
from .Events import notify_event_context, notify_event_topology
@@ -94,15 +97,40 @@ def topology_set(db_engine : Engine, messagebroker : MessageBroker, request : To
if len(topology_name) == 0: topology_name = request.topology_id.topology_uuid.uuid
context_uuid,topology_uuid = topology_get_uuid(request.topology_id, topology_name=topology_name, allow_random=True)
- # Ignore request.device_ids and request.link_ids. They are used for retrieving devices and links added into the
- # topology. Explicit addition into the topology is done automatically when creating the devices and links, based
- # on the topologies specified in the endpoints associated with the devices and links.
+ # By default, ignore request.device_ids and request.link_ids. They are used for retrieving
+ # devices and links added into the topology. Explicit addition into the topology is done
+ # automatically when creating the devices and links, based on the topologies specified in
+ # the endpoints associated with the devices and links.
+ # In some cases, it might be needed to add them explicitly; to allow that, activate flags
+ # ALLOW_EXPLICIT_ADD_DEVICE_TO_TOPOLOGY and/or ALLOW_EXPLICIT_ADD_LINK_TO_TOPOLOGY.
- if len(request.device_ids) > 0: # pragma: no cover
- LOGGER.warning('Items in field "device_ids" ignored. This field is used for retrieval purposes only.')
+ related_devices : List[Dict] = list()
+ if ALLOW_EXPLICIT_ADD_DEVICE_TO_TOPOLOGY:
+ device_uuids : Set[str] = set()
+ for device_id in request.device_ids:
+ device_uuid = device_get_uuid(device_id)
+ if device_uuid not in device_uuids: continue
+ related_devices.append({'topology_uuid': topology_uuid, 'device_uuid': device_uuid})
+ device_uuids.add(device_uuid)
+ else:
+ if len(request.device_ids) > 0: # pragma: no cover
+ MSG = 'ALLOW_EXPLICIT_ADD_DEVICE_TO_TOPOLOGY={:s}; '.format(str(ALLOW_EXPLICIT_ADD_DEVICE_TO_TOPOLOGY))
+ MSG += 'Items in field "device_ids" ignored. This field is used for retrieval purposes only.'
+ LOGGER.warning(MSG)
- if len(request.link_ids) > 0: # pragma: no cover
- LOGGER.warning('Items in field "link_ids" ignored. This field is used for retrieval purposes only.')
+ related_links : List[Dict] = list()
+ if ALLOW_EXPLICIT_ADD_LINK_TO_TOPOLOGY:
+ link_uuids : Set[str] = set()
+ for link_id in request.link_ids:
+ link_uuid = link_get_uuid(link_id)
+ if link_uuid not in link_uuids: continue
+ related_links.append({'topology_uuid': topology_uuid, 'link_uuid': link_uuid})
+ link_uuids.add(link_uuid)
+ else:
+ if len(request.link_ids) > 0: # pragma: no cover
+ MSG = 'ALLOW_EXPLICIT_ADD_LINK_TO_TOPOLOGY={:s}; '.format(str(ALLOW_EXPLICIT_ADD_LINK_TO_TOPOLOGY))
+ MSG += 'Items in field "link_ids" ignored. This field is used for retrieval purposes only.'
+ LOGGER.warning(MSG)
now = datetime.datetime.utcnow()
topology_data = [{
@@ -124,7 +152,28 @@ def topology_set(db_engine : Engine, messagebroker : MessageBroker, request : To
)
stmt = stmt.returning(TopologyModel.created_at, TopologyModel.updated_at)
created_at,updated_at = session.execute(stmt).fetchone()
- return updated_at > created_at
+
+ updated = updated_at > created_at
+
+ updated_topology_device = False
+ if len(related_devices) > 0:
+ stmt = insert(TopologyDeviceModel).values(related_devices)
+ stmt = stmt.on_conflict_do_nothing(
+ index_elements=[TopologyDeviceModel.topology_uuid, TopologyDeviceModel.device_uuid]
+ )
+ topology_device_inserts = session.execute(stmt)
+ updated_topology_device = int(topology_device_inserts.rowcount) > 0
+
+ updated_topology_link = False
+ if len(related_links) > 0:
+ stmt = insert(TopologyLinkModel).values(related_links)
+ stmt = stmt.on_conflict_do_nothing(
+ index_elements=[TopologyLinkModel.topology_uuid, TopologyLinkModel.link_uuid]
+ )
+ topology_link_inserts = session.execute(stmt)
+ updated_topology_link = int(topology_link_inserts.rowcount) > 0
+
+ return updated or updated_topology_device or updated_topology_link
updated = run_transaction(sessionmaker(bind=db_engine), callback)
context_id = json_context_id(context_uuid)
diff --git a/src/context/tests/test_link.py b/src/context/tests/test_link.py
index 8b07f0230cc12add4ab0f2db78f3663cb021ca3a..5b5abb0d53d25778c0e5cd11b7d97c4a35746a4e 100644
--- a/src/context/tests/test_link.py
+++ b/src/context/tests/test_link.py
@@ -100,8 +100,13 @@ def test_link(context_client : ContextClient) -> None:
attribute_names = set([field.name for field,_ in response.attributes.ListFields()])
assert 'total_capacity_gbps' in attribute_names
assert abs(response.attributes.total_capacity_gbps - 100) < 1.e-12
- assert 'used_capacity_gbps' in attribute_names
- assert abs(response.attributes.used_capacity_gbps - response.attributes.total_capacity_gbps) < 1.e-12
+ assert (
+ ('used_capacity_gbps' not in attribute_names) or (
+ ('used_capacity_gbps' in attribute_names) and (
+ abs(response.attributes.used_capacity_gbps - response.attributes.total_capacity_gbps) < 1.e-12
+ )
+ )
+ )
# ----- List when the object exists --------------------------------------------------------------------------------
response = context_client.ListLinkIds(Empty())
diff --git a/src/nbi/.gitlab-ci.yml b/src/nbi/.gitlab-ci.yml
index 0b12f9f08b9705ce51f7ff36f0446d9c83c85bbd..d9d790803a5cb0387d2d3447ef700154879bb615 100644
--- a/src/nbi/.gitlab-ci.yml
+++ b/src/nbi/.gitlab-ci.yml
@@ -48,15 +48,28 @@ unit_test nbi:
- build nbi
before_script:
- docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
- - if docker network list | grep teraflowbridge; then echo "teraflowbridge is already created"; else docker network create -d bridge teraflowbridge; fi
- - if docker container ls | grep $IMAGE_NAME; then docker rm -f $IMAGE_NAME; else echo "$IMAGE_NAME image is not in the system"; fi
+ - >
+ if docker network list | grep teraflowbridge; then
+ echo "teraflowbridge is already created";
+ else
+ docker network create -d bridge teraflowbridge;
+ fi
+ - >
+ if docker container ls | grep $IMAGE_NAME; then
+ docker rm -f $IMAGE_NAME;
+ else
+ echo "$IMAGE_NAME image is not in the system";
+ fi
script:
- docker pull "$CI_REGISTRY_IMAGE/$IMAGE_NAME:$IMAGE_TAG"
- docker run --name $IMAGE_NAME -d -p 9090:9090 -v "$PWD/src/$IMAGE_NAME/tests:/opt/results" --network=teraflowbridge $CI_REGISTRY_IMAGE/$IMAGE_NAME:$IMAGE_TAG
- sleep 5
- docker ps -a
- docker logs $IMAGE_NAME
- - docker exec -i $IMAGE_NAME bash -c "coverage run -m pytest --log-level=INFO --verbose $IMAGE_NAME/tests/test_unitary.py --junitxml=/opt/results/${IMAGE_NAME}_report.xml"
+ - docker exec -i $IMAGE_NAME bash -c "coverage run --append -m pytest --log-level=INFO --verbose $IMAGE_NAME/tests/test_ietf_l2vpn.py --junitxml=/opt/results/${IMAGE_NAME}_report_ietf_l2vpn.xml"
+ - docker exec -i $IMAGE_NAME bash -c "coverage run --append -m pytest --log-level=INFO --verbose $IMAGE_NAME/tests/test_ietf_network.py --junitxml=/opt/results/${IMAGE_NAME}_report_ietf_network.xml"
+ - docker exec -i $IMAGE_NAME bash -c "coverage run --append -m pytest --log-level=INFO --verbose $IMAGE_NAME/tests/test_ietf_l3vpn.py --junitxml=/opt/results/${IMAGE_NAME}_report_ietf_l3vpn.xml"
+ - docker exec -i $IMAGE_NAME bash -c "coverage run --append -m pytest --log-level=INFO --verbose $IMAGE_NAME/tests/test_etsi_bwm.py --junitxml=/opt/results/${IMAGE_NAME}_report_etsi_bwm.xml"
- docker exec -i $IMAGE_NAME bash -c "coverage report --include='${IMAGE_NAME}/*' --show-missing"
coverage: '/TOTAL\s+\d+\s+\d+\s+(\d+%)/'
after_script:
@@ -77,7 +90,7 @@ unit_test nbi:
artifacts:
when: always
reports:
- junit: src/$IMAGE_NAME/tests/${IMAGE_NAME}_report.xml
+ junit: src/$IMAGE_NAME/tests/${IMAGE_NAME}_report_*.xml
## Deployment of the service in Kubernetes Cluster
#deploy nbi:
diff --git a/src/nbi/Dockerfile b/src/nbi/Dockerfile
index 12b3c86747d927a11c3688322846efc6de0607c6..eda4d295697e94b659f67d75025d1944db703afc 100644
--- a/src/nbi/Dockerfile
+++ b/src/nbi/Dockerfile
@@ -53,6 +53,21 @@ RUN python3 -m grpc_tools.protoc -I=. --python_out=. --grpc_python_out=. *.proto
RUN rm *.proto
RUN find . -type f -exec sed -i -E 's/(import\ .*)_pb2/from . \1_pb2/g' {} \;
+# Download, build and install libyang. Note that APT package is outdated
+# - Ref: https://github.com/CESNET/libyang
+# - Ref: https://github.com/CESNET/libyang-python/
+RUN apt-get --yes --quiet --quiet update && \
+ apt-get --yes --quiet --quiet install build-essential cmake libpcre2-dev python3-dev python3-cffi && \
+ rm -rf /var/lib/apt/lists/*
+RUN mkdir -p /var/libyang
+RUN git clone https://github.com/CESNET/libyang.git /var/libyang
+RUN mkdir -p /var/libyang/build
+WORKDIR /var/libyang/build
+RUN cmake -D CMAKE_BUILD_TYPE:String="Release" ..
+RUN make
+RUN make install
+RUN ldconfig
+
# Create component sub-folders, get specific Python packages
RUN mkdir -p /var/teraflow/nbi
WORKDIR /var/teraflow/nbi
@@ -63,9 +78,14 @@ RUN python3 -m pip install -r requirements.txt
# Add component files into working directory
WORKDIR /var/teraflow
COPY src/nbi/. nbi/
-COPY src/context/. context/
-COPY src/service/. service/
-COPY src/slice/. slice/
+COPY src/context/__init__.py context/__init__.py
+COPY src/context/client/. context/client/
+COPY src/device/__init__.py device/__init__.py
+COPY src/device/client/. device/client/
+COPY src/service/__init__.py service/__init__.py
+COPY src/service/client/. service/client/
+COPY src/slice/__init__.py slice/__init__.py
+COPY src/slice/client/. slice/client/
RUN mkdir -p /var/teraflow/tests/tools
COPY src/tests/tools/mock_osm/. tests/tools/mock_osm/
diff --git a/src/nbi/README.md b/src/nbi/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c5ed72704b7d6048d3829eb8f77710e51753b000
--- /dev/null
+++ b/src/nbi/README.md
@@ -0,0 +1,32 @@
+# NBI Component
+
+The NBI component uses libyang to validate and process messages. Follow instructions below to install it.
+
+## Install libyang
+- Ref: https://github.com/CESNET/libyang
+- Ref: https://github.com/CESNET/libyang-python/
+
+__NOTE__: APT package is extremely outdated and does not work for our purposes.
+
+### Build Requisites
+```bash
+sudo apt-get install build-essential cmake libpcre2-dev
+sudo apt-get install python3-dev gcc python3-cffi
+```
+
+### Build from source
+```bash
+mkdir ~/tfs-ctrl/libyang
+git clone https://github.com/CESNET/libyang.git ~/tfs-ctrl/libyang
+mkdir ~/tfs-ctrl/libyang/build
+cd ~/tfs-ctrl/libyang/build
+cmake -D CMAKE_BUILD_TYPE:String="Release" ..
+make
+sudo make install
+sudo ldconfig
+```
+
+### Install Python bindings
+```bash
+pip install libyang==2.8.0
+```
diff --git a/src/nbi/requirements.in b/src/nbi/requirements.in
index dc22f64eb79778f89d1e66d9718dfed2c15457a3..6e3eb94404f9d12431c715080cf210a02c7c82f4 100644
--- a/src/nbi/requirements.in
+++ b/src/nbi/requirements.in
@@ -12,9 +12,15 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+deepdiff==6.7.*
+deepmerge==1.1.*
Flask==2.1.3
Flask-HTTPAuth==4.5.0
Flask-RESTful==0.3.9
jsonschema==4.4.0
+libyang==2.8.0
+netaddr==0.9.0
+pyang==2.6.0
+git+https://github.com/robshakir/pyangbind.git
requests==2.27.1
-werkzeug==2.3.7
\ No newline at end of file
+werkzeug==2.3.7
diff --git a/src/nbi/service/__main__.py b/src/nbi/service/__main__.py
index 1b6fb6e87c0f47e2e5f115fdf910d963180d644b..8834e45a2779c8d422ba1f9878c435f14a2f43db 100644
--- a/src/nbi/service/__main__.py
+++ b/src/nbi/service/__main__.py
@@ -23,6 +23,8 @@ from .rest_server.RestServer import RestServer
from .rest_server.nbi_plugins.debug_api import register_debug_api
from .rest_server.nbi_plugins.etsi_bwm import register_etsi_bwm_api
from .rest_server.nbi_plugins.ietf_l2vpn import register_ietf_l2vpn
+from .rest_server.nbi_plugins.ietf_l3vpn import register_ietf_l3vpn
+from .rest_server.nbi_plugins.ietf_network import register_ietf_network
from .rest_server.nbi_plugins.ietf_network_slice import register_ietf_nss
terminate = threading.Event()
@@ -63,6 +65,8 @@ def main():
register_debug_api(rest_server)
register_etsi_bwm_api(rest_server)
register_ietf_l2vpn(rest_server) # Registering L2VPN entrypoint
+ register_ietf_l3vpn(rest_server) # Registering L3VPN entrypoint
+ register_ietf_network(rest_server)
register_ietf_nss(rest_server) # Registering NSS entrypoint
rest_server.start()
diff --git a/src/nbi/service/rest_server/nbi_plugins/debug_api/Resources.py b/src/nbi/service/rest_server/nbi_plugins/debug_api/Resources.py
index 5573b7b026b18715f31a91a052c1a5b15c97a5f0..5fb46a30294eeec4e07de2ec1ce8387775726c23 100644
--- a/src/nbi/service/rest_server/nbi_plugins/debug_api/Resources.py
+++ b/src/nbi/service/rest_server/nbi_plugins/debug_api/Resources.py
@@ -12,8 +12,11 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+import json
+from flask.json import jsonify
from flask_restful import Resource, request
from common.proto.context_pb2 import Empty
+from common.tools.grpc.Tools import grpc_message_to_json
from context.client.ContextClient import ContextClient
from service.client.ServiceClient import ServiceClient
from .Tools import (
@@ -34,6 +37,66 @@ class Contexts(_Resource):
def get(self):
return format_grpc_to_json(self.client.ListContexts(Empty()))
+class DummyContexts(_Resource):
+ def get(self):
+ contexts = grpc_message_to_json(self.client.ListContexts(Empty()), use_integers_for_enums=True)['contexts']
+ devices = grpc_message_to_json(self.client.ListDevices(Empty()), use_integers_for_enums=True)['devices']
+ links = grpc_message_to_json(self.client.ListLinks(Empty()), use_integers_for_enums=True)['links']
+
+ topologies = list()
+ slices = list()
+ services = list()
+ connections = list()
+
+ for context in contexts:
+ context_uuid = context['context_id']['context_uuid']['uuid']
+ context_id = grpc_context_id(context_uuid)
+
+ topologies.extend(grpc_message_to_json(
+ self.client.ListTopologies(context_id),
+ use_integers_for_enums=True
+ )['topologies'])
+
+ slices.extend(grpc_message_to_json(
+ self.client.ListSlices(context_id),
+ use_integers_for_enums=True
+ )['slices'])
+
+ context_services = grpc_message_to_json(
+ self.client.ListServices(context_id),
+ use_integers_for_enums=True
+ )['services']
+ services.extend(context_services)
+
+ for service in context_services:
+ service_uuid = service['service_id']['service_uuid']['uuid']
+ service_id = grpc_service_id(context_uuid, service_uuid)
+ connections.extend(grpc_message_to_json(
+ self.client.ListConnections(service_id),
+ use_integers_for_enums=True
+ )['connections'])
+
+ for device in devices:
+ for config_rule in device['device_config']['config_rules']:
+ if 'custom' not in config_rule: continue
+ resource_value = config_rule['custom']['resource_value']
+ if not isinstance(resource_value, str): continue
+ try:
+ resource_value = json.loads(resource_value)
+ except: # pylint: disable=bare-except
+ pass
+ config_rule['custom']['resource_value'] = resource_value
+
+ dummy_context = {'dummy_mode': True}
+ if len(contexts ) > 0: dummy_context['contexts' ] = contexts
+ if len(topologies ) > 0: dummy_context['topologies' ] = topologies
+ if len(devices ) > 0: dummy_context['devices' ] = devices
+ if len(links ) > 0: dummy_context['links' ] = links
+ if len(slices ) > 0: dummy_context['slices' ] = slices
+ if len(services ) > 0: dummy_context['services' ] = services
+ if len(connections) > 0: dummy_context['connections'] = connections
+ return jsonify(dummy_context)
+
class Context(_Resource):
def get(self, context_uuid : str):
return format_grpc_to_json(self.client.GetContext(grpc_context_id(context_uuid)))
@@ -62,7 +125,7 @@ class Service(_Resource):
def get(self, context_uuid : str, service_uuid : str):
return format_grpc_to_json(self.client.GetService(grpc_service_id(context_uuid, service_uuid)))
- def post(self, context_uuid : str, service_uuid : str):
+ def post(self, context_uuid : str, service_uuid : str): # pylint: disable=unused-argument
service = request.get_json()['services'][0]
return format_grpc_to_json(self.service_client.CreateService(grpc_service(
service_uuid = service['service_id']['service_uuid']['uuid'],
@@ -70,7 +133,7 @@ class Service(_Resource):
context_uuid = service['service_id']['context_id']['context_uuid']['uuid'],
)))
- def put(self, context_uuid : str, service_uuid : str):
+ def put(self, context_uuid : str, service_uuid : str): # pylint: disable=unused-argument
service = request.get_json()['services'][0]
return format_grpc_to_json(self.service_client.UpdateService(grpc_service(
service_uuid = service['service_id']['service_uuid']['uuid'],
diff --git a/src/nbi/service/rest_server/nbi_plugins/debug_api/__init__.py b/src/nbi/service/rest_server/nbi_plugins/debug_api/__init__.py
index 46dc6fccfe0c3d27c66317295d77e18df2f8ecc4..1ccf93144eca4017bc41d6e62aa76260a4ce69f5 100644
--- a/src/nbi/service/rest_server/nbi_plugins/debug_api/__init__.py
+++ b/src/nbi/service/rest_server/nbi_plugins/debug_api/__init__.py
@@ -14,9 +14,16 @@
from nbi.service.rest_server.RestServer import RestServer
from .Resources import (
- Connection, ConnectionIds, Connections, Context, ContextIds, Contexts, Device, DeviceIds, Devices, Link, LinkIds,
- Links, PolicyRule, PolicyRuleIds, PolicyRules, Service, ServiceIds, Services, Slice, SliceIds, Slices, Topologies,
- Topology, TopologyIds)
+ Connection, ConnectionIds, Connections,
+ Context, ContextIds, Contexts,
+ Device, DeviceIds, Devices,
+ DummyContexts,
+ Link, LinkIds, Links,
+ PolicyRule, PolicyRuleIds, PolicyRules,
+ Service, ServiceIds, Services,
+ Slice, SliceIds, Slices,
+ Topologies, Topology, TopologyIds
+)
URL_PREFIX = '/debug-api'
@@ -25,6 +32,7 @@ RESOURCES = [
# (endpoint_name, resource_class, resource_url)
('api.context_ids', ContextIds, '/context_ids'),
('api.contexts', Contexts, '/contexts'),
+ ('api.dummy_contexts', DummyContexts, '/dummy_contexts'),
('api.context', Context, '/context/<path:context_uuid>'),
('api.topology_ids', TopologyIds, '/context/<path:context_uuid>/topology_ids'),
diff --git a/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/Resources.py b/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/Resources.py
index 38534b754d6c1ac502b21af55375c63159c57745..3fccbbb55c8959ae0c478526d2ea24882ebfef1f 100644
--- a/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/Resources.py
+++ b/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/Resources.py
@@ -12,14 +12,15 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import copy
+import copy, deepmerge, json, logging
from common.Constants import DEFAULT_CONTEXT_NAME
-from flask_restful import Resource, request
from context.client.ContextClient import ContextClient
+from flask_restful import Resource, request
from service.client.ServiceClient import ServiceClient
from .Tools import (
format_grpc_to_json, grpc_context_id, grpc_service_id, bwInfo_2_service, service_2_bwInfo)
+LOGGER = logging.getLogger(__name__)
class _Resource(Resource):
@@ -39,7 +40,6 @@ class BwInfo(_Resource):
bwinfo = request.get_json()
service = bwInfo_2_service(self.client, bwinfo)
stripped_service = copy.deepcopy(service)
-
stripped_service.ClearField('service_endpoint_ids')
stripped_service.ClearField('service_constraints')
stripped_service.ClearField('service_config')
@@ -57,19 +57,30 @@ class BwInfoId(_Resource):
return service_2_bwInfo(service)
def put(self, allocationId: str):
- json_data = request.get_json()
+ json_data = json.loads(request.get_json())
service = bwInfo_2_service(self.client, json_data)
- response = self.service_client.UpdateService(service)
- return format_grpc_to_json(response)
+ self.service_client.UpdateService(service)
+ service = self.client.GetService(grpc_service_id(DEFAULT_CONTEXT_NAME, json_data['appInsId']))
+ response_bwm = service_2_bwInfo(service)
+
+ return response_bwm
def patch(self, allocationId: str):
json_data = request.get_json()
if not 'appInsId' in json_data:
json_data['appInsId'] = allocationId
- service = bwInfo_2_service(self.client, json_data)
- response = self.service_client.UpdateService(service)
- return format_grpc_to_json(response)
+
+ service = self.client.GetService(grpc_service_id(DEFAULT_CONTEXT_NAME, json_data['appInsId']))
+ current_bwm = service_2_bwInfo(service)
+ new_bmw = deepmerge.always_merger.merge(current_bwm, json_data)
+
+ service = bwInfo_2_service(self.client, new_bmw)
+ self.service_client.UpdateService(service)
+
+ service = self.client.GetService(grpc_service_id(DEFAULT_CONTEXT_NAME, json_data['appInsId']))
+ response_bwm = service_2_bwInfo(service)
+
+ return response_bwm
def delete(self, allocationId: str):
self.service_client.DeleteService(grpc_service_id(DEFAULT_CONTEXT_NAME, allocationId))
- return
diff --git a/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/Tools.py b/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/Tools.py
index 023d1006cd807ffeeed40d2e1e7273a580431073..a78d2819317623b9ccaaec62e808f6435c88b630 100644
--- a/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/Tools.py
+++ b/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/Tools.py
@@ -15,8 +15,11 @@
import json
import logging
import time
+from decimal import ROUND_HALF_EVEN, Decimal
from flask.json import jsonify
-from common.proto.context_pb2 import ContextId, Empty, EndPointId, ServiceId, ServiceTypeEnum, Service, Constraint, Constraint_SLA_Capacity, ConfigRule, ConfigRule_Custom, ConfigActionEnum
+from common.proto.context_pb2 import (
+ ContextId, Empty, EndPointId, ServiceId, ServiceTypeEnum, Service, Constraint, Constraint_SLA_Capacity,
+ ConfigRule, ConfigRule_Custom, ConfigActionEnum)
from common.tools.grpc.Tools import grpc_message_to_json
from common.tools.object_factory.Context import json_context_id
from common.tools.object_factory.Service import json_service_id
@@ -27,13 +30,15 @@ LOGGER = logging.getLogger(__name__)
def service_2_bwInfo(service: Service) -> dict:
response = {}
# allocationDirection = '??' # String: 00 = Downlink (towards the UE); 01 = Uplink (towards the application/session); 10 = Symmetrical
- response['appInsId'] = service.service_id.context_id.context_uuid.uuid # String: Application instance identifier
+ response['appInsId'] = service.service_id.service_uuid.uuid # String: Application instance identifier
for constraint in service.service_constraints:
if constraint.WhichOneof('constraint') == 'sla_capacity':
- response['fixedAllocation'] = str(constraint.sla_capacity.capacity_gbps*1000) # String: Size of requested fixed BW allocation in [bps]
+ # String: Size of requested fixed BW allocation in [bps]
+ fixed_allocation = Decimal(constraint.sla_capacity.capacity_gbps * 1.e9)
+ fixed_allocation = fixed_allocation.quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN)
+ response['fixedAllocation'] = str(fixed_allocation)
break
-
for config_rule in service.service_config.config_rules:
for key in ['allocationDirection', 'fixedBWPriority', 'requestType', 'sourceIp', 'sourcePort', 'dstPort', 'protocol', 'sessionFilter']:
if config_rule.custom.resource_key == key:
@@ -42,7 +47,6 @@ def service_2_bwInfo(service: Service) -> dict:
else:
response[key] = json.loads(config_rule.custom.resource_value)
-
unixtime = time.time()
response['timeStamp'] = { # Time stamp to indicate when the corresponding information elements are sent
"seconds": int(unixtime),
@@ -53,7 +57,6 @@ def service_2_bwInfo(service: Service) -> dict:
def bwInfo_2_service(client, bwInfo: dict) -> Service:
service = Service()
-
for key in ['allocationDirection', 'fixedBWPriority', 'requestType', 'timeStamp', 'sessionFilter']:
if key not in bwInfo:
continue
@@ -82,10 +85,6 @@ def bwInfo_2_service(client, bwInfo: dict) -> Service:
ep_id.endpoint_uuid.uuid = ep['uuid']
ep_id.device_id.device_uuid.uuid = device.device_id.device_uuid.uuid
service.service_endpoint_ids.append(ep_id)
-
- if len(service.service_endpoint_ids) < 2:
- LOGGER.error('No endpoints matched')
- return None
service.service_type = ServiceTypeEnum.SERVICETYPE_L3NM
@@ -96,7 +95,7 @@ def bwInfo_2_service(client, bwInfo: dict) -> Service:
if 'fixedAllocation' in bwInfo:
capacity = Constraint_SLA_Capacity()
- capacity.capacity_gbps = float(bwInfo['fixedAllocation'])
+ capacity.capacity_gbps = float(bwInfo['fixedAllocation']) / 1.e9
constraint = Constraint()
constraint.sla_capacity.CopyFrom(capacity)
service.service_constraints.append(constraint)
diff --git a/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/__init__.py b/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/__init__.py
index 5525c58ad9f0def5001d9a6430ffe5fb2c5efe33..f34432d82ee302d97cb2caaf3ed1628dc6e9f005 100644
--- a/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/__init__.py
+++ b/src/nbi/service/rest_server/nbi_plugins/etsi_bwm/__init__.py
@@ -15,7 +15,7 @@
from nbi.service.rest_server.RestServer import RestServer
from .Resources import BwInfo, BwInfoId
-URL_PREFIX = '/bwm/v1'
+URL_PREFIX = '/restconf/bwm/v1'
# Use 'path' type since some identifiers might contain char '/' and Flask is unable to recognize them in 'string' type.
RESOURCES = [
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/Handlers.py b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/Handlers.py
new file mode 100644
index 0000000000000000000000000000000000000000..8490eb91581dc80f837e2baec851553560fc9deb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/Handlers.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.
+
+import logging, netaddr
+from typing import Dict, List, Optional, Tuple
+from common.Constants import DEFAULT_CONTEXT_NAME
+from common.proto.context_pb2 import Service, ServiceStatusEnum
+from common.tools.context_queries.Service import get_service_by_uuid
+from common.tools.grpc.ConfigRules import update_config_rule_custom
+from common.tools.grpc.Constraints import (
+ update_constraint_endpoint_location, update_constraint_sla_availability, update_constraint_sla_capacity,
+ update_constraint_sla_latency
+)
+from common.tools.grpc.EndPointIds import update_endpoint_ids
+from context.client.ContextClient import ContextClient
+from service.client.ServiceClient import ServiceClient
+
+LOGGER = logging.getLogger(__name__)
+
+def create_service(
+ service_uuid : str, context_uuid : Optional[str] = DEFAULT_CONTEXT_NAME
+) -> Optional[Exception]:
+ # pylint: disable=no-member
+ service_request = Service()
+ service_request.service_id.context_id.context_uuid.uuid = context_uuid
+ service_request.service_id.service_uuid.uuid = service_uuid
+ service_request.service_status.service_status = ServiceStatusEnum.SERVICESTATUS_PLANNED
+
+ try:
+ service_client = ServiceClient()
+ service_client.CreateService(service_request)
+ return None
+ except Exception as e: # pylint: disable=broad-except
+ LOGGER.exception('Unhandled exception creating Service')
+ return e
+
+def process_vpn_service(
+ vpn_service : Dict, errors : List[Dict]
+) -> None:
+ vpn_id = vpn_service['vpn-id']
+ exc = create_service(vpn_id)
+ if exc is not None: errors.append({'error': str(exc)})
+
+def update_service_endpoint(
+ service_uuid : str, site_id : str, device_uuid : str, endpoint_uuid : str,
+ vlan_tag : int, ipv4_address : str, ipv4_prefix_length : int,
+ capacity_gbps : Optional[float] = None, e2e_latency_ms : Optional[float] = None,
+ availability : Optional[float] = None, mtu : Optional[int] = None,
+ context_uuid : Optional[str] = DEFAULT_CONTEXT_NAME,
+) -> Optional[Exception]:
+ context_client = ContextClient()
+ service = get_service_by_uuid(context_client, service_uuid, context_uuid=context_uuid, rw_copy=True)
+ if service is None: raise Exception('VPN({:s}) not found in database'.format(str(service_uuid)))
+
+ endpoint_ids = service.service_endpoint_ids
+ endpoint_id = update_endpoint_ids(endpoint_ids, device_uuid, endpoint_uuid)
+
+ constraints = service.service_constraints
+ update_constraint_endpoint_location(constraints, endpoint_id, region=site_id)
+ if capacity_gbps is not None: update_constraint_sla_capacity (constraints, capacity_gbps)
+ if e2e_latency_ms is not None: update_constraint_sla_latency (constraints, e2e_latency_ms)
+ if availability is not None: update_constraint_sla_availability(constraints, 1, True, availability)
+
+ config_rules = service.service_config.config_rules
+
+ service_settings_key = '/settings'
+ service_settings = {'address_families': (['IPV4'], True)}
+ if mtu is not None: service_settings['mtu'] = (mtu, True)
+ update_config_rule_custom(config_rules, service_settings_key, service_settings)
+
+ ENDPOINT_SETTINGS_KEY = '/device[{:s}]/endpoint[{:s}]/vlan[{:d}]/settings'
+ endpoint_settings_key = ENDPOINT_SETTINGS_KEY.format(device_uuid, endpoint_uuid, vlan_tag)
+ field_updates = {}
+ if vlan_tag is not None: field_updates['vlan_tag' ] = (vlan_tag, True)
+ if ipv4_address is not None: field_updates['ip_address' ] = (ipv4_address, True)
+ if ipv4_prefix_length is not None: field_updates['prefix_length'] = (ipv4_prefix_length, True)
+ update_config_rule_custom(config_rules, endpoint_settings_key, field_updates)
+
+ try:
+ service_client = ServiceClient()
+ service_client.UpdateService(service)
+ return None
+ except Exception as e: # pylint: disable=broad-except
+ LOGGER.exception('Unhandled exception updating Service')
+ return e
+
+def process_site_network_access(
+ site_id : str, network_access : Dict, site_static_routing : Dict[Tuple[str, str], str], errors : List[Dict]
+) -> None:
+ endpoint_uuid = network_access['site-network-access-id']
+
+ if network_access['site-network-access-type'] != 'ietf-l3vpn-svc:multipoint':
+ MSG = 'Site Network Access Type: {:s}'
+ raise NotImplementedError(MSG.format(str(network_access['site-network-access-type'])))
+
+ device_uuid = network_access['device-reference']
+ service_uuid = network_access['vpn-attachment']['vpn-id']
+
+ access_role : str = network_access['vpn-attachment']['site-role']
+ access_role = access_role.replace('ietf-l3vpn-svc:', '').replace('-role', '') # hub/spoke
+ if access_role not in {'hub', 'spoke'}:
+ MSG = 'Site VPN Attackment Role: {:s}'
+ raise NotImplementedError(MSG.format(str(network_access['site-network-access-type'])))
+
+ ipv4_allocation = network_access['ip-connection']['ipv4']
+ if ipv4_allocation['address-allocation-type'] != 'ietf-l3vpn-svc:static-address':
+ MSG = 'Site Network Access IPv4 Allocation Type: {:s}'
+ raise NotImplementedError(MSG.format(str(ipv4_allocation['address-allocation-type'])))
+ ipv4_allocation_addresses = ipv4_allocation['addresses']
+ ipv4_provider_address = ipv4_allocation_addresses['provider-address']
+ #ipv4_customer_address = ipv4_allocation_addresses['customer-address']
+ ipv4_prefix_length = ipv4_allocation_addresses['prefix-length' ]
+
+ vlan_tag = None
+ ipv4_provider_range = netaddr.IPNetwork('{:s}/{:d}'.format(ipv4_provider_address, ipv4_prefix_length))
+ for (_, _, lan_tag), next_hop in site_static_routing.items():
+ ip_next_hop = netaddr.IPAddress(next_hop)
+ if ip_next_hop not in ipv4_provider_range: continue
+ vlan_tag = lan_tag
+ break
+
+ ## network_access_static_routing: (lan-range, lan-prefix-len, lan-tag) => next-hop
+ #network_access_static_routing : Dict[Tuple[str, str], str] = {}
+ #for rt_proto in network_access['routing-protocols']['routing-protocol']:
+ # if rt_proto['type'] != 'ietf-l3vpn-svc:static':
+ # MSG = 'Site Network Access Routing Protocol Type: {:s}'
+ # raise NotImplementedError(MSG.format(str(rt_proto['type'])))
+ # for ipv4_rt in rt_proto['static']['cascaded-lan-prefixes']['ipv4-lan-prefixes']:
+ # lan_range, lan_prefix = ipv4_rt['lan'].split('/')
+ # lan_prefix = int(lan_prefix)
+ # lan_tag = int(ipv4_rt['lan-tag'].replace('vlan', ''))
+ # next_hop = ipv4_rt['next-hop']
+ # network_access_static_routing[(lan_range, lan_prefix, lan_tag)] = next_hop
+
+ service_mtu = network_access['service']['svc-mtu']
+ service_input_bandwidth = network_access['service']['svc-input-bandwidth']
+ service_output_bandwidth = network_access['service']['svc-output-bandwidth']
+ service_bandwidth_bps = max(service_input_bandwidth, service_output_bandwidth)
+ service_bandwidth_gbps = service_bandwidth_bps / 1.e9
+
+ max_e2e_latency_ms = None
+ availability = None
+ for qos_profile_class in network_access['service']['qos']['qos-profile']['classes']['class']:
+ if qos_profile_class['class-id'] != 'qos-realtime':
+ MSG = 'Site Network Access QoS Class Id: {:s}'
+ raise NotImplementedError(MSG.format(str(qos_profile_class['class-id'])))
+
+ if qos_profile_class['direction'] != 'ietf-l3vpn-svc:both':
+ MSG = 'Site Network Access QoS Class Direction: {:s}'
+ raise NotImplementedError(MSG.format(str(qos_profile_class['direction'])))
+
+ max_e2e_latency_ms = qos_profile_class['latency']['latency-boundary']
+ availability = qos_profile_class['bandwidth']['guaranteed-bw-percent']
+
+ exc = update_service_endpoint(
+ service_uuid, site_id, device_uuid, endpoint_uuid, vlan_tag, ipv4_provider_address, ipv4_prefix_length,
+ capacity_gbps=service_bandwidth_gbps, e2e_latency_ms=max_e2e_latency_ms, availability=availability,
+ mtu=service_mtu
+ )
+ if exc is not None: errors.append({'error': str(exc)})
+
+def process_site(site : Dict, errors : List[Dict]) -> None:
+ site_id = site['site-id']
+
+ if site['management']['type'] != 'ietf-l3vpn-svc:provider-managed':
+ MSG = 'Site Management Type: {:s}'
+ raise NotImplementedError(MSG.format(str(site['management']['type'])))
+
+ # site_static_routing: (lan-range, lan-prefix-len, lan-tag) => next-hop
+ site_static_routing : Dict[Tuple[str, str], str] = {}
+ for rt_proto in site['routing-protocols']['routing-protocol']:
+ if rt_proto['type'] != 'ietf-l3vpn-svc:static':
+ MSG = 'Site Routing Protocol Type: {:s}'
+ raise NotImplementedError(MSG.format(str(rt_proto['type'])))
+ for ipv4_rt in rt_proto['static']['cascaded-lan-prefixes']['ipv4-lan-prefixes']:
+ lan_range, lan_prefix = ipv4_rt['lan'].split('/')
+ lan_prefix = int(lan_prefix)
+ lan_tag = int(ipv4_rt['lan-tag'].replace('vlan', ''))
+ next_hop = ipv4_rt['next-hop']
+ site_static_routing[(lan_range, lan_prefix, lan_tag)] = next_hop
+
+ network_accesses : List[Dict] = site['site-network-accesses']['site-network-access']
+ for network_access in network_accesses:
+ process_site_network_access(site_id, network_access, site_static_routing, errors)
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_Service.py b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_Service.py
new file mode 100644
index 0000000000000000000000000000000000000000..470ff0add7a42ff027f3c6fe95426653aee214a4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_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 import request
+from flask.json import jsonify
+from flask_restful import Resource
+from common.proto.context_pb2 import ServiceStatusEnum
+from common.tools.context_queries.Service import get_service_by_uuid
+from context.client.ContextClient import ContextClient
+from service.client.ServiceClient import ServiceClient
+from ..tools.Authentication import HTTP_AUTH
+from ..tools.HttpStatusCodes import HTTP_GATEWAYTIMEOUT, HTTP_NOCONTENT, HTTP_OK, HTTP_SERVERERROR
+
+LOGGER = logging.getLogger(__name__)
+
+class L3VPN_Service(Resource):
+ @HTTP_AUTH.login_required
+ def get(self, vpn_id : str):
+ LOGGER.debug('VPN_Id: {:s}'.format(str(vpn_id)))
+ LOGGER.debug('Request: {:s}'.format(str(request)))
+
+ try:
+ context_client = ContextClient()
+
+ target = get_service_by_uuid(context_client, vpn_id, rw_copy=True)
+ if target is None:
+ raise Exception('VPN({:s}) not found in database'.format(str(vpn_id)))
+
+ service_ids = {target.service_id.service_uuid.uuid, target.name} # pylint: disable=no-member
+ if vpn_id not in service_ids:
+ raise Exception('Service retrieval failed. Wrong Service Id was returned')
+
+ service_ready_status = ServiceStatusEnum.SERVICESTATUS_ACTIVE
+ service_status = target.service_status.service_status # pylint: disable=no-member
+ response = jsonify({})
+ response.status_code = HTTP_OK if service_status == service_ready_status else HTTP_GATEWAYTIMEOUT
+ except Exception as e: # pylint: disable=broad-except
+ LOGGER.exception('Something went wrong Retrieving VPN({:s})'.format(str(vpn_id)))
+ response = jsonify({'error': str(e)})
+ response.status_code = HTTP_SERVERERROR
+ return response
+
+ @HTTP_AUTH.login_required
+ def delete(self, vpn_id : str):
+ LOGGER.debug('VPN_Id: {:s}'.format(str(vpn_id)))
+ LOGGER.debug('Request: {:s}'.format(str(request)))
+
+ try:
+ context_client = ContextClient()
+
+ target = get_service_by_uuid(context_client, vpn_id)
+ if target is None:
+ LOGGER.warning('VPN({:s}) not found in database. Nothing done.'.format(str(vpn_id)))
+ else:
+ service_ids = {target.service_id.service_uuid.uuid, target.name} # pylint: disable=no-member
+ if vpn_id not in service_ids:
+ raise Exception('Service retrieval failed. Wrong Service Id was returned')
+ service_client = ServiceClient()
+ service_client.DeleteService(target.service_id)
+ response = jsonify({})
+ response.status_code = HTTP_NOCONTENT
+ except Exception as e: # pylint: disable=broad-except
+ LOGGER.exception('Something went wrong Deleting VPN({:s})'.format(str(vpn_id)))
+ response = jsonify({'error': str(e)})
+ response.status_code = HTTP_SERVERERROR
+ return response
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_Services.py b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_Services.py
new file mode 100644
index 0000000000000000000000000000000000000000..13d5c532478e93ef1bd3b1c644d7f3c3ba927af5
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_Services.py
@@ -0,0 +1,53 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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 typing import Dict
+from flask import request
+from flask.json import jsonify
+from flask_restful import Resource
+from werkzeug.exceptions import UnsupportedMediaType
+from nbi.service.rest_server.nbi_plugins.tools.HttpStatusCodes import HTTP_CREATED, HTTP_SERVERERROR
+from nbi.service.rest_server.nbi_plugins.tools.Authentication import HTTP_AUTH
+from .Handlers import process_site, process_vpn_service
+from .YangValidator import YangValidator
+
+LOGGER = logging.getLogger(__name__)
+
+class L3VPN_Services(Resource):
+ @HTTP_AUTH.login_required
+ def get(self):
+ return {}
+
+ @HTTP_AUTH.login_required
+ def post(self):
+ if not request.is_json: raise UnsupportedMediaType('JSON payload is required')
+ request_data : Dict = request.json
+ LOGGER.debug('Request: {:s}'.format(str(request_data)))
+
+ yang_validator = YangValidator('ietf-l3vpn-svc')
+ request_data = yang_validator.parse_to_dict(request_data)
+ yang_validator.destroy()
+
+ errors = []
+
+ for vpn_service in request_data['l3vpn-svc']['vpn-services']['vpn-service']:
+ process_vpn_service(vpn_service, errors)
+
+ for site in request_data['l3vpn-svc']['sites']['site']:
+ process_site(site, errors)
+
+ response = jsonify(errors)
+ response.status_code = HTTP_CREATED if len(errors) == 0 else HTTP_SERVERERROR
+ return response
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_SiteNetworkAccesses.py b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_SiteNetworkAccesses.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd0334789af67bb2b9e7083a3794dbd3a7c948df
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_SiteNetworkAccesses.py
@@ -0,0 +1,58 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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 typing import Dict
+from flask import request
+from flask.json import jsonify
+from flask.wrappers import Response
+from flask_restful import Resource
+from werkzeug.exceptions import UnsupportedMediaType
+from nbi.service.rest_server.nbi_plugins.tools.Authentication import HTTP_AUTH
+from nbi.service.rest_server.nbi_plugins.tools.HttpStatusCodes import HTTP_CREATED, HTTP_SERVERERROR
+from .Handlers import process_site_network_access
+from .YangValidator import YangValidator
+
+LOGGER = logging.getLogger(__name__)
+
+def process_site_network_accesses(site_id : str) -> Response:
+ if not request.is_json: raise UnsupportedMediaType('JSON payload is required')
+ request_data : Dict = request.json
+ LOGGER.debug('Site_Id: {:s}'.format(str(site_id)))
+ LOGGER.debug('Request: {:s}'.format(str(request_data)))
+
+ yang_validator = YangValidator('ietf-l3vpn-svc')
+ request_data = yang_validator.parse_to_dict(request_data)
+ yang_validator.destroy()
+
+ # TODO: retrieve site static routing from service
+ site_static_routing = dict()
+
+ errors = []
+ for network_access in request_data['site-network-accesses']['site-network-access']:
+ exc = process_site_network_access(site_id, network_access, site_static_routing, errors)
+ if exc is not None: errors.append({'error': str(exc)})
+
+ response = jsonify(errors)
+ response.status_code = HTTP_CREATED if len(errors) == 0 else HTTP_SERVERERROR
+ return response
+
+class L3VPN_SiteNetworkAccesses(Resource):
+ @HTTP_AUTH.login_required
+ def post(self, site_id : str):
+ return process_site_network_accesses(site_id)
+
+ @HTTP_AUTH.login_required
+ def put(self, site_id : str):
+ return process_site_network_accesses(site_id)
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/YangValidator.py b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/YangValidator.py
new file mode 100644
index 0000000000000000000000000000000000000000..d267640dd43d3400517c488c65ae786422c073bc
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/YangValidator.py
@@ -0,0 +1,36 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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 libyang, os
+from typing import Dict, Optional
+
+YANG_DIR = os.path.join(os.path.dirname(__file__), 'yang')
+
+class YangValidator:
+ def __init__(self, module_name : str) -> None:
+ self._yang_context = libyang.Context(YANG_DIR)
+ self._yang_module = self._yang_context.load_module(module_name)
+ self._yang_module.feature_enable_all()
+
+ def parse_to_dict(self, message : Dict) -> Dict:
+ dnode : Optional[libyang.DNode] = self._yang_module.parse_data_dict(
+ message, validate_present=True, validate=True, strict=True
+ )
+ if dnode is None: raise Exception('Unable to parse Message({:s})'.format(str(message)))
+ message = dnode.print_dict()
+ dnode.free()
+ return message
+
+ def destroy(self) -> None:
+ self._yang_context.destroy()
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..454e10b841eed19a1837762825b4fd61ae21e4c4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/__init__.py
@@ -0,0 +1,41 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# RFC 8299 - YANG Data Model for L3VPN Service Delivery
+# Ref: https://datatracker.ietf.org/doc/rfc8299
+
+from flask_restful import Resource
+from nbi.service.rest_server.RestServer import RestServer
+from .L3VPN_Services import L3VPN_Services
+from .L3VPN_Service import L3VPN_Service
+from .L3VPN_SiteNetworkAccesses import L3VPN_SiteNetworkAccesses
+
+URL_PREFIX = '/restconf/data/ietf-l3vpn-svc:l3vpn-svc'
+
+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_l3vpn(rest_server : RestServer):
+ _add_resource(rest_server, L3VPN_Services,
+ '/vpn-services',
+ )
+ _add_resource(rest_server, L3VPN_Service,
+ '/vpn-services/vpn-service=<vpn_id>',
+ '/vpn-services/vpn-service=<vpn_id>/',
+ )
+ _add_resource(rest_server, L3VPN_SiteNetworkAccesses,
+ '/sites/site=<site_id>/site-network-accesses',
+ '/sites/site=<site_id>/site-network-accesses/',
+ )
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-inet-types@2013-07-15.yang b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-inet-types@2013-07-15.yang
new file mode 100644
index 0000000000000000000000000000000000000000..790bafc31dd7dc3582ef1c765fe104145b8a6016
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-inet-types@2013-07-15.yang
@@ -0,0 +1,459 @@
+ module ietf-inet-types {
+
+ namespace "urn:ietf:params:xml:ns:yang:ietf-inet-types";
+ prefix "inet";
+
+ organization
+ "IETF NETMOD (NETCONF Data Modeling Language) Working Group";
+
+ contact
+ "WG Web: <http://tools.ietf.org/wg/netmod/>
+ WG List: <mailto:netmod@ietf.org>
+
+ WG Chair: David Kessens
+ <mailto:david.kessens@nsn.com>
+
+ WG Chair: Juergen Schoenwaelder
+ <mailto:j.schoenwaelder@jacobs-university.de>
+
+ Editor: Juergen Schoenwaelder
+ <mailto:j.schoenwaelder@jacobs-university.de>";
+
+ description
+ "This module contains a collection of generally useful derived
+ YANG data types for Internet addresses and related things.
+
+ Copyright (c) 2013 IETF Trust and the persons identified as
+ authors of the code. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or
+ without modification, is permitted pursuant to, and subject
+ to the license terms contained in, the Simplified BSD License
+ set forth in Section 4.c of the IETF Trust's Legal Provisions
+ Relating to IETF Documents
+ (http://trustee.ietf.org/license-info).
+
+ This version of this YANG module is part of RFC 6991; see
+ the RFC itself for full legal notices.";
+
+ revision 2013-07-15 {
+ description
+ "This revision adds the following new data types:
+ - ip-address-no-zone
+ - ipv4-address-no-zone
+ - ipv6-address-no-zone";
+ reference
+ "RFC 6991: Common YANG Data Types";
+ }
+
+ revision 2010-09-24 {
+ description
+ "Initial revision.";
+ reference
+ "RFC 6021: Common YANG Data Types";
+ }
+
+ /*** collection of types related to protocol fields ***/
+
+ typedef ip-version {
+ type enumeration {
+ enum unknown {
+ value "0";
+ description
+ "An unknown or unspecified version of the Internet
+ protocol.";
+ }
+ enum ipv4 {
+ value "1";
+ description
+ "The IPv4 protocol as defined in RFC 791.";
+ }
+ enum ipv6 {
+ value "2";
+ description
+ "The IPv6 protocol as defined in RFC 2460.";
+ }
+ }
+ description
+ "This value represents the version of the IP protocol.
+
+ In the value set and its semantics, this type is equivalent
+ to the InetVersion textual convention of the SMIv2.";
+ reference
+ "RFC 791: Internet Protocol
+ RFC 2460: Internet Protocol, Version 6 (IPv6) Specification
+ RFC 4001: Textual Conventions for Internet Network Addresses";
+ }
+
+ typedef dscp {
+ type uint8 {
+ range "0..63";
+ }
+ description
+ "The dscp type represents a Differentiated Services Code Point
+ that may be used for marking packets in a traffic stream.
+
+ In the value set and its semantics, this type is equivalent
+ to the Dscp textual convention of the SMIv2.";
+ reference
+ "RFC 3289: Management Information Base for the Differentiated
+ Services Architecture
+ RFC 2474: Definition of the Differentiated Services Field
+ (DS Field) in the IPv4 and IPv6 Headers
+ RFC 2780: IANA Allocation Guidelines For Values In
+ the Internet Protocol and Related Headers";
+ }
+
+ typedef ipv6-flow-label {
+ type uint32 {
+ range "0..1048575";
+ }
+ description
+ "The ipv6-flow-label type represents the flow identifier or Flow
+ Label in an IPv6 packet header that may be used to
+ discriminate traffic flows.
+
+ In the value set and its semantics, this type is equivalent
+ to the IPv6FlowLabel textual convention of the SMIv2.";
+ reference
+ "RFC 3595: Textual Conventions for IPv6 Flow Label
+ RFC 2460: Internet Protocol, Version 6 (IPv6) Specification";
+ }
+
+ typedef port-number {
+ type uint16 {
+ range "0..65535";
+ }
+ description
+ "The port-number type represents a 16-bit port number of an
+ Internet transport-layer protocol such as UDP, TCP, DCCP, or
+ SCTP. Port numbers are assigned by IANA. A current list of
+ all assignments is available from <http://www.iana.org/>.
+
+ Note that the port number value zero is reserved by IANA. In
+ situations where the value zero does not make sense, it can
+ be excluded by subtyping the port-number type.
+ In the value set and its semantics, this type is equivalent
+ to the InetPortNumber textual convention of the SMIv2.";
+ reference
+ "RFC 768: User Datagram Protocol
+ RFC 793: Transmission Control Protocol
+ RFC 4960: Stream Control Transmission Protocol
+ RFC 4340: Datagram Congestion Control Protocol (DCCP)
+ RFC 4001: Textual Conventions for Internet Network Addresses";
+ }
+
+ /*** collection of types related to autonomous systems ***/
+
+ typedef as-number {
+ type uint32;
+ description
+ "The as-number type represents autonomous system numbers
+ which identify an Autonomous System (AS). An AS is a set
+ of routers under a single technical administration, using
+ an interior gateway protocol and common metrics to route
+ packets within the AS, and using an exterior gateway
+ protocol to route packets to other ASes. IANA maintains
+ the AS number space and has delegated large parts to the
+ regional registries.
+
+ Autonomous system numbers were originally limited to 16
+ bits. BGP extensions have enlarged the autonomous system
+ number space to 32 bits. This type therefore uses an uint32
+ base type without a range restriction in order to support
+ a larger autonomous system number space.
+
+ In the value set and its semantics, this type is equivalent
+ to the InetAutonomousSystemNumber textual convention of
+ the SMIv2.";
+ reference
+ "RFC 1930: Guidelines for creation, selection, and registration
+ of an Autonomous System (AS)
+ RFC 4271: A Border Gateway Protocol 4 (BGP-4)
+ RFC 4001: Textual Conventions for Internet Network Addresses
+ RFC 6793: BGP Support for Four-Octet Autonomous System (AS)
+ Number Space";
+ }
+
+ /*** collection of types related to IP addresses and hostnames ***/
+
+ typedef ip-address {
+ type union {
+ type inet:ipv4-address;
+ type inet:ipv6-address;
+ }
+ description
+ "The ip-address type represents an IP address and is IP
+ version neutral. The format of the textual representation
+ implies the IP version. This type supports scoped addresses
+ by allowing zone identifiers in the address format.";
+ reference
+ "RFC 4007: IPv6 Scoped Address Architecture";
+ }
+
+ typedef ipv4-address {
+ type string {
+ pattern
+ '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}'
+ + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'
+ + '(%[\p{N}\p{L}]+)?';
+ }
+ description
+ "The ipv4-address type represents an IPv4 address in
+ dotted-quad notation. The IPv4 address may include a zone
+ index, separated by a % sign.
+
+ The zone index is used to disambiguate identical address
+ values. For link-local addresses, the zone index will
+ typically be the interface index number or the name of an
+ interface. If the zone index is not present, the default
+ zone of the device will be used.
+
+ The canonical format for the zone index is the numerical
+ format";
+ }
+
+ typedef ipv6-address {
+ type string {
+ pattern '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}'
+ + '((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|'
+ + '(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}'
+ + '(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))'
+ + '(%[\p{N}\p{L}]+)?';
+ pattern '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|'
+ + '((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)'
+ + '(%.+)?';
+ }
+ description
+ "The ipv6-address type represents an IPv6 address in full,
+ mixed, shortened, and shortened-mixed notation. The IPv6
+ address may include a zone index, separated by a % sign.
+
+ The zone index is used to disambiguate identical address
+ values. For link-local addresses, the zone index will
+ typically be the interface index number or the name of an
+ interface. If the zone index is not present, the default
+ zone of the device will be used.
+
+ The canonical format of IPv6 addresses uses the textual
+ representation defined in Section 4 of RFC 5952. The
+ canonical format for the zone index is the numerical
+ format as described in Section 11.2 of RFC 4007.";
+ reference
+ "RFC 4291: IP Version 6 Addressing Architecture
+ RFC 4007: IPv6 Scoped Address Architecture
+ RFC 5952: A Recommendation for IPv6 Address Text
+ Representation";
+ }
+
+ typedef ip-address-no-zone {
+ type union {
+ type inet:ipv4-address-no-zone;
+ type inet:ipv6-address-no-zone;
+ }
+ description
+ "The ip-address-no-zone type represents an IP address and is
+ IP version neutral. The format of the textual representation
+ implies the IP version. This type does not support scoped
+ addresses since it does not allow zone identifiers in the
+ address format.";
+ reference
+ "RFC 4007: IPv6 Scoped Address Architecture";
+ }
+
+ typedef ipv4-address-no-zone {
+ type inet:ipv4-address {
+ pattern '[0-9\.]*';
+ }
+ description
+ "An IPv4 address without a zone index. This type, derived from
+ ipv4-address, may be used in situations where the zone is
+ known from the context and hence no zone index is needed.";
+ }
+
+ typedef ipv6-address-no-zone {
+ type inet:ipv6-address {
+ pattern '[0-9a-fA-F:\.]*';
+ }
+ description
+ "An IPv6 address without a zone index. This type, derived from
+ ipv6-address, may be used in situations where the zone is
+ known from the context and hence no zone index is needed.";
+ reference
+ "RFC 4291: IP Version 6 Addressing Architecture
+ RFC 4007: IPv6 Scoped Address Architecture
+ RFC 5952: A Recommendation for IPv6 Address Text
+ Representation";
+ }
+
+ typedef ip-prefix {
+ type union {
+ type inet:ipv4-prefix;
+ type inet:ipv6-prefix;
+ }
+ description
+ "The ip-prefix type represents an IP prefix and is IP
+ version neutral. The format of the textual representations
+ implies the IP version.";
+ }
+
+ typedef ipv4-prefix {
+ type string {
+ pattern
+ '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}'
+ + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'
+ + '/(([0-9])|([1-2][0-9])|(3[0-2]))';
+ }
+ description
+ "The ipv4-prefix type represents an IPv4 address prefix.
+ The prefix length is given by the number following the
+ slash character and must be less than or equal to 32.
+
+ A prefix length value of n corresponds to an IP address
+ mask that has n contiguous 1-bits from the most
+ significant bit (MSB) and all other bits set to 0.
+
+ The canonical format of an IPv4 prefix has all bits of
+ the IPv4 address set to zero that are not part of the
+ IPv4 prefix.";
+ }
+
+ typedef ipv6-prefix {
+ type string {
+ pattern '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}'
+ + '((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|'
+ + '(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}'
+ + '(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))'
+ + '(/(([0-9])|([0-9]{2})|(1[0-1][0-9])|(12[0-8])))';
+ pattern '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|'
+ + '((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)'
+ + '(/.+)';
+ }
+
+ description
+ "The ipv6-prefix type represents an IPv6 address prefix.
+ The prefix length is given by the number following the
+ slash character and must be less than or equal to 128.
+
+ A prefix length value of n corresponds to an IP address
+ mask that has n contiguous 1-bits from the most
+ significant bit (MSB) and all other bits set to 0.
+
+ The IPv6 address should have all bits that do not belong
+ to the prefix set to zero.
+
+ The canonical format of an IPv6 prefix has all bits of
+ the IPv6 address set to zero that are not part of the
+ IPv6 prefix. Furthermore, the IPv6 address is represented
+ as defined in Section 4 of RFC 5952.";
+ reference
+ "RFC 5952: A Recommendation for IPv6 Address Text
+ Representation";
+ }
+
+ /*** collection of domain name and URI types ***/
+
+ typedef domain-name {
+ type string {
+ pattern
+ '((([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.)*'
+ + '([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.?)'
+ + '|\.';
+ length "1..253";
+ }
+ description
+ "The domain-name type represents a DNS domain name. The
+ name SHOULD be fully qualified whenever possible.
+
+ Internet domain names are only loosely specified. Section
+ 3.5 of RFC 1034 recommends a syntax (modified in Section
+ 2.1 of RFC 1123). The pattern above is intended to allow
+ for current practice in domain name use, and some possible
+ future expansion. It is designed to hold various types of
+ domain names, including names used for A or AAAA records
+ (host names) and other records, such as SRV records. Note
+ that Internet host names have a stricter syntax (described
+ in RFC 952) than the DNS recommendations in RFCs 1034 and
+ 1123, and that systems that want to store host names in
+ schema nodes using the domain-name type are recommended to
+ adhere to this stricter standard to ensure interoperability.
+
+ The encoding of DNS names in the DNS protocol is limited
+ to 255 characters. Since the encoding consists of labels
+ prefixed by a length bytes and there is a trailing NULL
+ byte, only 253 characters can appear in the textual dotted
+ notation.
+
+ The description clause of schema nodes using the domain-name
+ type MUST describe when and how these names are resolved to
+ IP addresses. Note that the resolution of a domain-name value
+ may require to query multiple DNS records (e.g., A for IPv4
+ and AAAA for IPv6). The order of the resolution process and
+ which DNS record takes precedence can either be defined
+ explicitly or may depend on the configuration of the
+ resolver.
+
+ Domain-name values use the US-ASCII encoding. Their canonical
+ format uses lowercase US-ASCII characters. Internationalized
+ domain names MUST be A-labels as per RFC 5890.";
+ reference
+ "RFC 952: DoD Internet Host Table Specification
+ RFC 1034: Domain Names - Concepts and Facilities
+ RFC 1123: Requirements for Internet Hosts -- Application
+ and Support
+ RFC 2782: A DNS RR for specifying the location of services
+ (DNS SRV)
+ RFC 5890: Internationalized Domain Names in Applications
+ (IDNA): Definitions and Document Framework";
+ }
+
+ typedef host {
+ type union {
+ type inet:ip-address;
+ type inet:domain-name;
+ }
+ description
+ "The host type represents either an IP address or a DNS
+ domain name.";
+ }
+
+ typedef uri {
+ type string;
+ description
+ "The uri type represents a Uniform Resource Identifier
+ (URI) as defined by STD 66.
+
+ Objects using the uri type MUST be in US-ASCII encoding,
+ and MUST be normalized as described by RFC 3986 Sections
+ 6.2.1, 6.2.2.1, and 6.2.2.2. All unnecessary
+ percent-encoding is removed, and all case-insensitive
+ characters are set to lowercase except for hexadecimal
+ digits, which are normalized to uppercase as described in
+ Section 6.2.2.1.
+
+ The purpose of this normalization is to help provide
+ unique URIs. Note that this normalization is not
+ sufficient to provide uniqueness. Two URIs that are
+ textually distinct after this normalization may still be
+ equivalent.
+
+ Objects using the uri type may restrict the schemes that
+ they permit. For example, 'data:' and 'urn:' schemes
+ might not be appropriate.
+
+ A zero-length URI is not a valid URI. This can be used to
+ express 'URI absent' where required.
+
+ In the value set and its semantics, this type is equivalent
+ to the Uri SMIv2 textual convention defined in RFC 5017.";
+ reference
+ "RFC 3986: Uniform Resource Identifier (URI): Generic Syntax
+ RFC 3305: Report from the Joint W3C/IETF URI Planning Interest
+ Group: Uniform Resource Identifiers (URIs), URLs,
+ and Uniform Resource Names (URNs): Clarifications
+ and Recommendations
+ RFC 5017: MIB Textual Conventions for Uniform Resource
+ Identifiers (URIs)";
+ }
+
+ }
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-l3vpn-svc@2018-01-19.yang b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-l3vpn-svc@2018-01-19.yang
new file mode 100644
index 0000000000000000000000000000000000000000..e05e33722f01fc9af9cbeb07092dc6287e8dc6c4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-l3vpn-svc@2018-01-19.yang
@@ -0,0 +1,2856 @@
+ module ietf-l3vpn-svc {
+ yang-version 1.1;
+ namespace "urn:ietf:params:xml:ns:yang:ietf-l3vpn-svc";
+ prefix l3vpn-svc;
+ import ietf-inet-types {
+ prefix inet;
+ }
+ import ietf-yang-types {
+ prefix yang;
+ }
+ import ietf-netconf-acm {
+ prefix nacm;
+ }
+ organization
+ "IETF L3SM Working Group";
+ contact
+ "WG List: <mailto:l3sm@ietf.org>
+ Editor:
+ L3SM WG
+ Chairs:
+ Adrian Farrel, Qin Wu
+ ";
+ description
+ "This YANG module defines a generic service configuration
+ model for Layer 3 VPNs. This model is common across all
+ vendor implementations.
+
+
+
+
+ Copyright (c) 2018 IETF Trust and the persons
+ identified as authors of the code. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or
+ without modification, is permitted pursuant to, and subject
+ to the license terms contained in, the Simplified BSD License
+ set forth in Section 4.c of the IETF Trust's Legal Provisions
+ Relating to IETF Documents
+ (https://trustee.ietf.org/license-info).
+
+ This version of this YANG module is part of RFC 8299; see
+ the RFC itself for full legal notices.";
+
+ revision 2018-01-19 {
+ description
+ "Revision of RFC 8049 to fix implementation issues.";
+ reference
+ "RFC 8299";
+ }
+ revision 2017-01-27 {
+ description
+ "Initial document.";
+ reference
+ "RFC 8049.";
+ }
+ /* Features */
+ feature cloud-access {
+ description
+ "Allows the VPN to connect to a CSP.";
+ }
+ feature multicast {
+ description
+ "Enables multicast capabilities in a VPN.";
+ }
+ feature ipv4 {
+ description
+ "Enables IPv4 support in a VPN.";
+ }
+ feature ipv6 {
+ description
+ "Enables IPv6 support in a VPN.";
+ }
+ feature lan-tag {
+ description
+ "Enables LAN Tag support in a VPN Policy filter.";
+ }
+ feature carrierscarrier {
+ description
+
+ "Enables support of CsC.";
+ }
+ feature extranet-vpn {
+ description
+ "Enables support of extranet VPNs.";
+ }
+ feature site-diversity {
+ description
+ "Enables support of site diversity constraints.";
+ }
+ feature encryption {
+ description
+ "Enables support of encryption.";
+ }
+ feature qos {
+ description
+ "Enables support of classes of services.";
+ }
+ feature qos-custom {
+ description
+ "Enables support of the custom QoS profile.";
+ }
+ feature rtg-bgp {
+ description
+ "Enables support of the BGP routing protocol.";
+ }
+ feature rtg-rip {
+ description
+ "Enables support of the RIP routing protocol.";
+ }
+ feature rtg-ospf {
+ description
+ "Enables support of the OSPF routing protocol.";
+ }
+ feature rtg-ospf-sham-link {
+ description
+ "Enables support of OSPF sham links.";
+ }
+ feature rtg-vrrp {
+ description
+ "Enables support of the VRRP routing protocol.";
+ }
+ feature fast-reroute {
+ description
+ "Enables support of Fast Reroute.";
+ }
+ feature bfd {
+ description
+
+ "Enables support of BFD.";
+ }
+ feature always-on {
+ description
+ "Enables support of the 'always-on' access constraint.";
+ }
+ feature requested-type {
+ description
+ "Enables support of the 'requested-type' access constraint.";
+ }
+ feature bearer-reference {
+ description
+ "Enables support of the 'bearer-reference' access constraint.";
+ }
+ feature target-sites {
+ description
+ "Enables support of the 'target-sites' match flow parameter.";
+ }
+ /* Typedefs */
+ typedef svc-id {
+ type string;
+ description
+ "Defines a type of service component identifier.";
+ }
+ typedef template-id {
+ type string;
+ description
+ "Defines a type of service template identifier.";
+ }
+ typedef address-family {
+ type enumeration {
+ enum ipv4 {
+ description
+ "IPv4 address family.";
+ }
+ enum ipv6 {
+ description
+ "IPv6 address family.";
+ }
+ }
+ description
+ "Defines a type for the address family.";
+ }
+ /* Identities */
+ identity site-network-access-type {
+ description
+ "Base identity for site-network-access type.";
+ }
+
+ identity point-to-point {
+ base site-network-access-type;
+ description
+ "Identity for point-to-point connection.";
+ }
+ identity multipoint {
+ base site-network-access-type;
+ description
+ "Identity for multipoint connection.
+ Example: Ethernet broadcast segment.";
+ }
+ identity placement-diversity {
+ description
+ "Base identity for site placement constraints.";
+ }
+ identity bearer-diverse {
+ base placement-diversity;
+ description
+ "Identity for bearer diversity.
+ The bearers should not use common elements.";
+ }
+ identity pe-diverse {
+ base placement-diversity;
+ description
+ "Identity for PE diversity.";
+ }
+ identity pop-diverse {
+ base placement-diversity;
+ description
+ "Identity for POP diversity.";
+ }
+ identity linecard-diverse {
+ base placement-diversity;
+ description
+ "Identity for linecard diversity.";
+ }
+ identity same-pe {
+ base placement-diversity;
+ description
+ "Identity for having sites connected on the same PE.";
+ }
+ identity same-bearer {
+ base placement-diversity;
+ description
+ "Identity for having sites connected using the same bearer.";
+ }
+ identity customer-application {
+ description
+
+ "Base identity for customer application.";
+ }
+ identity web {
+ base customer-application;
+ description
+ "Identity for Web application (e.g., HTTP, HTTPS).";
+ }
+ identity mail {
+ base customer-application;
+ description
+ "Identity for mail application.";
+ }
+ identity file-transfer {
+ base customer-application;
+ description
+ "Identity for file transfer application (e.g., FTP, SFTP).";
+ }
+ identity database {
+ base customer-application;
+ description
+ "Identity for database application.";
+ }
+ identity social {
+ base customer-application;
+ description
+ "Identity for social-network application.";
+ }
+ identity games {
+ base customer-application;
+ description
+ "Identity for gaming application.";
+ }
+ identity p2p {
+ base customer-application;
+ description
+ "Identity for peer-to-peer application.";
+ }
+ identity network-management {
+ base customer-application;
+ description
+ "Identity for management application
+ (e.g., Telnet, syslog, SNMP).";
+ }
+ identity voice {
+ base customer-application;
+ description
+ "Identity for voice application.";
+ }
+
+ identity video {
+ base customer-application;
+ description
+ "Identity for video conference application.";
+ }
+ identity embb {
+ base customer-application;
+ description
+ "Identity for an enhanced Mobile Broadband (eMBB)
+ application. Note that an eMBB application demands
+ network performance with a wide variety of
+ characteristics, such as data rate, latency,
+ loss rate, reliability, and many other parameters.";
+ }
+ identity urllc {
+ base customer-application;
+ description
+ "Identity for an Ultra-Reliable and Low Latency
+ Communications (URLLC) application. Note that a
+ URLLC application demands network performance
+ with a wide variety of characteristics, such as latency,
+ reliability, and many other parameters.";
+ }
+ identity mmtc {
+ base customer-application;
+ description
+ "Identity for a massive Machine Type
+ Communications (mMTC) application. Note that an
+ mMTC application demands network performance
+ with a wide variety of characteristics, such as data
+ rate, latency, loss rate, reliability, and many
+ other parameters.";
+ }
+ identity site-vpn-flavor {
+ description
+ "Base identity for the site VPN service flavor.";
+ }
+ identity site-vpn-flavor-single {
+ base site-vpn-flavor;
+ description
+ "Base identity for the site VPN service flavor.
+ Used when the site belongs to only one VPN.";
+ }
+ identity site-vpn-flavor-multi {
+ base site-vpn-flavor;
+ description
+ "Base identity for the site VPN service flavor.
+ Used when a logical connection of a site
+
+ belongs to multiple VPNs.";
+ }
+ identity site-vpn-flavor-sub {
+ base site-vpn-flavor;
+ description
+ "Base identity for the site VPN service flavor.
+ Used when a site has multiple logical connections.
+ Each connection may belong to different multiple VPNs.";
+ }
+ identity site-vpn-flavor-nni {
+ base site-vpn-flavor;
+ description
+ "Base identity for the site VPN service flavor.
+ Used to describe an NNI option A connection.";
+ }
+ identity management {
+ description
+ "Base identity for site management scheme.";
+ }
+ identity co-managed {
+ base management;
+ description
+ "Base identity for co-managed site.";
+ }
+ identity customer-managed {
+ base management;
+ description
+ "Base identity for customer-managed site.";
+ }
+ identity provider-managed {
+ base management;
+ description
+ "Base identity for provider-managed site.";
+ }
+ identity address-allocation-type {
+ description
+ "Base identity for address-allocation-type for PE-CE link.";
+ }
+ identity provider-dhcp {
+ base address-allocation-type;
+ description
+ "Provider network provides DHCP service to customer.";
+ }
+ identity provider-dhcp-relay {
+ base address-allocation-type;
+ description
+ "Provider network provides DHCP relay service to customer.";
+ }
+
+ identity provider-dhcp-slaac {
+ base address-allocation-type;
+ description
+ "Provider network provides DHCP service to customer,
+ as well as SLAAC.";
+ }
+ identity static-address {
+ base address-allocation-type;
+ description
+ "Provider-to-customer addressing is static.";
+ }
+ identity slaac {
+ base address-allocation-type;
+ description
+ "Use IPv6 SLAAC.";
+ }
+ identity site-role {
+ description
+ "Base identity for site type.";
+ }
+ identity any-to-any-role {
+ base site-role;
+ description
+ "Site in an any-to-any IP VPN.";
+ }
+ identity spoke-role {
+ base site-role;
+ description
+ "Spoke site in a Hub-and-Spoke IP VPN.";
+ }
+ identity hub-role {
+ base site-role;
+ description
+ "Hub site in a Hub-and-Spoke IP VPN.";
+ }
+ identity vpn-topology {
+ description
+ "Base identity for VPN topology.";
+ }
+ identity any-to-any {
+ base vpn-topology;
+ description
+ "Identity for any-to-any VPN topology.";
+ }
+ identity hub-spoke {
+ base vpn-topology;
+ description
+ "Identity for Hub-and-Spoke VPN topology.";
+
+ }
+ identity hub-spoke-disjoint {
+ base vpn-topology;
+ description
+ "Identity for Hub-and-Spoke VPN topology
+ where Hubs cannot communicate with each other.";
+ }
+ identity multicast-tree-type {
+ description
+ "Base identity for multicast tree type.";
+ }
+ identity ssm-tree-type {
+ base multicast-tree-type;
+ description
+ "Identity for SSM tree type.";
+ }
+ identity asm-tree-type {
+ base multicast-tree-type;
+ description
+ "Identity for ASM tree type.";
+ }
+ identity bidir-tree-type {
+ base multicast-tree-type;
+ description
+ "Identity for bidirectional tree type.";
+ }
+ identity multicast-rp-discovery-type {
+ description
+ "Base identity for RP discovery type.";
+ }
+ identity auto-rp {
+ base multicast-rp-discovery-type;
+ description
+ "Base identity for Auto-RP discovery type.";
+ }
+ identity static-rp {
+ base multicast-rp-discovery-type;
+ description
+ "Base identity for static type.";
+ }
+ identity bsr-rp {
+ base multicast-rp-discovery-type;
+ description
+ "Base identity for BSR discovery type.";
+ }
+ identity routing-protocol-type {
+ description
+ "Base identity for routing protocol type.";
+
+ }
+ identity ospf {
+ base routing-protocol-type;
+ description
+ "Identity for OSPF protocol type.";
+ }
+ identity bgp {
+ base routing-protocol-type;
+ description
+ "Identity for BGP protocol type.";
+ }
+ identity static {
+ base routing-protocol-type;
+ description
+ "Identity for static routing protocol type.";
+ }
+ identity rip {
+ base routing-protocol-type;
+ description
+ "Identity for RIP protocol type.";
+ }
+ identity vrrp {
+ base routing-protocol-type;
+ description
+ "Identity for VRRP protocol type.
+ This is to be used when LANs are directly connected
+ to PE routers.";
+ }
+ identity direct {
+ base routing-protocol-type;
+ description
+ "Identity for direct protocol type.";
+ }
+ identity protocol-type {
+ description
+ "Base identity for protocol field type.";
+ }
+ identity tcp {
+ base protocol-type;
+ description
+ "TCP protocol type.";
+ }
+ identity udp {
+ base protocol-type;
+ description
+ "UDP protocol type.";
+ }
+
+
+ identity icmp {
+ base protocol-type;
+ description
+ "ICMP protocol type.";
+ }
+ identity icmp6 {
+ base protocol-type;
+ description
+ "ICMPv6 protocol type.";
+ }
+ identity gre {
+ base protocol-type;
+ description
+ "GRE protocol type.";
+ }
+ identity ipip {
+ base protocol-type;
+ description
+ "IP-in-IP protocol type.";
+ }
+ identity hop-by-hop {
+ base protocol-type;
+ description
+ "Hop-by-Hop IPv6 header type.";
+ }
+ identity routing {
+ base protocol-type;
+ description
+ "Routing IPv6 header type.";
+ }
+ identity esp {
+ base protocol-type;
+ description
+ "ESP header type.";
+ }
+ identity ah {
+ base protocol-type;
+ description
+ "AH header type.";
+ }
+ identity vpn-policy-filter-type {
+ description
+ "Base identity for VPN Policy filter type.";
+ }
+ identity ipv4 {
+ base vpn-policy-filter-type;
+ description
+ "Identity for IPv4 Prefix filter type.";
+
+ }
+ identity ipv6 {
+ base vpn-policy-filter-type;
+ description
+ "Identity for IPv6 Prefix filter type.";
+ }
+ identity lan {
+ base vpn-policy-filter-type;
+ description
+ "Identity for LAN Tag filter type.";
+ }
+
+ identity qos-profile-direction {
+ description
+ "Base identity for QoS profile direction.";
+ }
+
+ identity site-to-wan {
+ base qos-profile-direction;
+ description
+ "Identity for Site-to-WAN direction.";
+ }
+ identity wan-to-site {
+ base qos-profile-direction;
+ description
+ "Identity for WAN-to-Site direction.";
+ }
+ identity both {
+ base qos-profile-direction;
+ description
+ "Identity for both WAN-to-Site direction
+ and Site-to-WAN direction.";
+ }
+ /* Groupings */
+ grouping vpn-service-cloud-access {
+ container cloud-accesses {
+ if-feature cloud-access;
+ list cloud-access {
+ key cloud-identifier;
+ leaf cloud-identifier {
+ type leafref {
+ path "/l3vpn-svc/vpn-profiles/"+
+ "valid-provider-identifiers/cloud-identifier/id";
+ }
+ description
+ "Identification of cloud service.
+ Local administration meaning.";
+ }
+
+ choice list-flavor {
+ case permit-any {
+ leaf permit-any {
+ type empty;
+ description
+ "Allows all sites.";
+ }
+ }
+ case deny-any-except {
+ leaf-list permit-site {
+ type leafref {
+ path "/l3vpn-svc/sites/site/site-id";
+ }
+ description
+ "Site ID to be authorized.";
+ }
+ }
+ case permit-any-except {
+ leaf-list deny-site {
+ type leafref {
+ path "/l3vpn-svc/sites/site/site-id";
+ }
+ description
+ "Site ID to be denied.";
+ }
+ }
+ description
+ "Choice for cloud access policy. By
+ default, all sites in the IP VPN MUST
+ be authorized to access the cloud.";
+ }
+ container address-translation {
+ container nat44 {
+ leaf enabled {
+ type boolean;
+ default false;
+ description
+ "Controls whether or not Network address
+ translation from IPv4 to IPv4 (NAT44)
+ [RFC3022] is required.";
+ }
+ leaf nat44-customer-address {
+ type inet:ipv4-address;
+ description
+ "Address to be used for network address
+ translation from IPv4 to IPv4. This is
+ to be used if the customer is providing
+ the IPv4 address. If the customer address
+
+ is not set, the model assumes that the
+ provider will allocate the address.";
+ }
+ description
+ "IPv4-to-IPv4 translation.";
+ }
+ description
+ "Container for NAT.";
+ }
+ description
+ "Cloud access configuration.";
+ }
+ description
+ "Container for cloud access configurations.";
+ }
+ description
+ "Grouping for VPN cloud definition.";
+ }
+ grouping multicast-rp-group-cfg {
+ choice group-format {
+ mandatory true;
+ case singleaddress {
+ leaf group-address {
+ type inet:ip-address;
+ description
+ "A single multicast group address.";
+ }
+ }
+ case startend {
+ leaf group-start {
+ type inet:ip-address;
+ description
+ "The first multicast group address in
+ the multicast group address range.";
+ }
+ leaf group-end {
+ type inet:ip-address;
+ description
+ "The last multicast group address in
+ the multicast group address range.";
+ }
+ }
+ description
+ "Choice for multicast group format.";
+ }
+ description
+ "This grouping defines multicast group or
+ multicast groups for RP-to-group mapping.";
+
+ }
+ grouping vpn-service-multicast {
+ container multicast {
+ if-feature multicast;
+ leaf enabled {
+ type boolean;
+ default false;
+ description
+ "Enables multicast.";
+ }
+ container customer-tree-flavors {
+ leaf-list tree-flavor {
+ type identityref {
+ base multicast-tree-type;
+ }
+ description
+ "Type of tree to be used.";
+ }
+ description
+ "Type of trees used by customer.";
+ }
+ container rp {
+ container rp-group-mappings {
+ list rp-group-mapping {
+ key id;
+ leaf id {
+ type uint16;
+ description
+ "Unique identifier for the mapping.";
+ }
+ container provider-managed {
+ leaf enabled {
+ type boolean;
+ default false;
+ description
+ "Set to true if the Rendezvous Point (RP)
+ must be a provider-managed node. Set to false
+ if it is a customer-managed node.";
+ }
+ leaf rp-redundancy {
+ type boolean;
+ default false;
+ description
+ "If true, a redundancy mechanism for the RP
+ is required.";
+ }
+ leaf optimal-traffic-delivery {
+ type boolean;
+
+ default false;
+ description
+ "If true, the SP must ensure that
+ traffic uses an optimal path. An SP may use
+ Anycast RP or RP-tree-to-SPT switchover
+ architectures.";
+ }
+ description
+ "Parameters for a provider-managed RP.";
+ }
+ leaf rp-address {
+ when "../provider-managed/enabled = 'false'" {
+ description
+ "Relevant when the RP is not provider-managed.";
+ }
+ type inet:ip-address;
+ mandatory true;
+ description
+ "Defines the address of the RP.
+ Used if the RP is customer-managed.";
+ }
+ container groups {
+ list group {
+ key id;
+ leaf id {
+ type uint16;
+ description
+ "Identifier for the group.";
+ }
+ uses multicast-rp-group-cfg;
+ description
+ "List of multicast groups.";
+ }
+ description
+ "Multicast groups associated with the RP.";
+ }
+ description
+ "List of RP-to-group mappings.";
+ }
+ description
+ "RP-to-group mappings parameters.";
+ }
+ container rp-discovery {
+ leaf rp-discovery-type {
+ type identityref {
+ base multicast-rp-discovery-type;
+ }
+ default static-rp;
+
+ description
+ "Type of RP discovery used.";
+ }
+ container bsr-candidates {
+ when "derived-from-or-self(../rp-discovery-type, "+
+ "'l3vpn-svc:bsr-rp')" {
+ description
+ "Only applicable if discovery type
+ is BSR-RP.";
+ }
+ leaf-list bsr-candidate-address {
+ type inet:ip-address;
+ description
+ "Address of BSR candidate.";
+ }
+ description
+ "Container for List of Customer
+ BSR candidate's addresses.";
+ }
+ description
+ "RP discovery parameters.";
+ }
+ description
+ "RP parameters.";
+ }
+ description
+ "Multicast global parameters for the VPN service.";
+ }
+ description
+ "Grouping for multicast VPN definition.";
+ }
+ grouping vpn-service-mpls {
+ leaf carrierscarrier {
+ if-feature carrierscarrier;
+ type boolean;
+ default false;
+ description
+ "The VPN is using CsC, and so MPLS is required.";
+ }
+ description
+ "Grouping for MPLS CsC definition.";
+ }
+ grouping customer-location-info {
+ container locations {
+ list location {
+ key location-id;
+ leaf location-id {
+ type svc-id;
+
+ description
+ "Identifier for a particular location.";
+ }
+ leaf address {
+ type string;
+ description
+ "Address (number and street) of the site.";
+ }
+ leaf postal-code {
+ type string;
+ description
+ "Postal code of the site.";
+ }
+ leaf state {
+ type string;
+ description
+ "State of the site. This leaf can also be
+ used to describe a region for a country that
+ does not have states.";
+ }
+ leaf city {
+ type string;
+ description
+ "City of the site.";
+ }
+ leaf country-code {
+ type string {
+ pattern '[A-Z]{2}';
+ }
+ description
+ "Country of the site.
+ Expressed as ISO ALPHA-2 code.";
+ }
+ description
+ "Location of the site.";
+ }
+ description
+ "List of locations for the site.";
+ }
+ description
+ "This grouping defines customer location parameters.";
+ }
+ grouping site-group {
+ container groups {
+ list group {
+ key group-id;
+ leaf group-id {
+ type string;
+
+ description
+ "Group-id the site belongs to.";
+ }
+ description
+ "List of group-ids.";
+ }
+ description
+ "Groups the site or site-network-access belongs to.";
+ }
+ description
+ "Grouping definition to assign
+ group-ids to site or site-network-access.";
+ }
+ grouping site-diversity {
+ container site-diversity {
+ if-feature site-diversity;
+ uses site-group;
+ description
+ "Diversity constraint type. All
+ site-network-accesses will inherit
+ the group values defined here.";
+ }
+ description
+ "This grouping defines site
+ diversity parameters.";
+ }
+ grouping access-diversity {
+ container access-diversity {
+ if-feature site-diversity;
+ uses site-group;
+ container constraints {
+ list constraint {
+ key constraint-type;
+ leaf constraint-type {
+ type identityref {
+ base placement-diversity;
+ }
+ description
+ "Diversity constraint type.";
+ }
+ container target {
+ choice target-flavor {
+ default id;
+ case id {
+ list group {
+ key group-id;
+ leaf group-id {
+ type string;
+
+ description
+ "The constraint will be applied against
+ this particular group-id for this site
+ network access level.";
+ }
+ description
+ "List of group-ids associated with one specific
+ constraint for this site network access level.";
+ }
+ }
+ case all-accesses {
+ leaf all-other-accesses {
+ type empty;
+ description
+ "The constraint will be applied against
+ all other site network accesses of this site.";
+ }
+ }
+ case all-groups {
+ leaf all-other-groups {
+ type empty;
+ description
+ "The constraint will be applied against
+ all other groups managed by the customer.";
+ }
+ }
+ description
+ "Choice for the target flavor definition.";
+ }
+ description
+ "The constraint will be applied against a
+ Specific target, and the target can be a list
+ of group-ids,all other site network accesses of
+ this site, or all other groups managed by the
+ customer.";
+ }
+ description
+ "List of constraints.";
+ }
+ description
+ "Placement constraints for this site network access.";
+ }
+ description
+ "Diversity parameters.";
+ }
+ description
+ "This grouping defines access diversity parameters.";
+ }
+
+ grouping operational-requirements {
+ leaf requested-site-start {
+ type yang:date-and-time;
+ description
+ "Optional leaf indicating requested date and
+ time when the service at a particular site is
+ expected to start.";
+ }
+
+ leaf requested-site-stop {
+ type yang:date-and-time;
+ description
+ "Optional leaf indicating requested date and
+ time when the service at a particular site is
+ expected to stop.";
+ }
+ description
+ "This grouping defines some operational
+ parameters.";
+ }
+ grouping operational-requirements-ops {
+ leaf actual-site-start {
+ type yang:date-and-time;
+ config false;
+ description
+ "Optional leaf indicating actual date and
+ time when the service at a particular site
+ actually started.";
+ }
+ leaf actual-site-stop {
+ type yang:date-and-time;
+ config false;
+ description
+ "Optional leaf indicating actual date and
+ time when the service at a particular site
+ actually stopped.";
+ }
+ description
+ "This grouping defines some operational
+ parameters.";
+ }
+ grouping flow-definition {
+ container match-flow {
+ leaf dscp {
+ type inet:dscp;
+ description
+ "DSCP value.";
+ }
+
+ leaf dot1p {
+ type uint8 {
+ range "0..7";
+ }
+ description
+ "802.1p matching.";
+ }
+ leaf ipv4-src-prefix {
+ type inet:ipv4-prefix;
+ description
+ "Match on IPv4 src address.";
+ }
+ leaf ipv6-src-prefix {
+ type inet:ipv6-prefix;
+ description
+ "Match on IPv6 src address.";
+ }
+ leaf ipv4-dst-prefix {
+ type inet:ipv4-prefix;
+ description
+ "Match on IPv4 dst address.";
+ }
+ leaf ipv6-dst-prefix {
+ type inet:ipv6-prefix;
+ description
+ "Match on IPv6 dst address.";
+ }
+ leaf l4-src-port {
+ type inet:port-number;
+ must "current() < ../l4-src-port-range/lower-port or "+
+ "current() > ../l4-src-port-range/upper-port" {
+ description
+ "If l4-src-port and l4-src-port-range/lower-port and
+ upper-port are set at the same time, l4-src-port
+ should not overlap with l4-src-port-range.";
+ }
+ description
+ "Match on Layer 4 src port.";
+ }
+ leaf-list target-sites {
+ if-feature target-sites;
+ type svc-id;
+ description
+ "Identify a site as traffic destination.";
+ }
+ container l4-src-port-range {
+ leaf lower-port {
+ type inet:port-number;
+
+ description
+ "Lower boundary for port.";
+ }
+ leaf upper-port {
+ type inet:port-number;
+ must ". >= ../lower-port" {
+ description
+ "Upper boundary for port. If it
+ exists, the upper boundary must be
+ higher than the lower boundary.";
+ }
+ description
+ "Upper boundary for port.";
+ }
+ description
+ "Match on Layer 4 src port range. When
+ only the lower-port is present, it represents
+ a single port. When both the lower-port and
+ upper-port are specified, it implies
+ a range inclusive of both values.";
+ }
+ leaf l4-dst-port {
+ type inet:port-number;
+ must "current() < ../l4-dst-port-range/lower-port or "+
+ "current() > ../l4-dst-port-range/upper-port" {
+ description
+ "If l4-dst-port and l4-dst-port-range/lower-port
+ and upper-port are set at the same time,
+ l4-dst-port should not overlap with
+ l4-src-port-range.";
+ }
+ description
+ "Match on Layer 4 dst port.";
+ }
+ container l4-dst-port-range {
+ leaf lower-port {
+ type inet:port-number;
+ description
+ "Lower boundary for port.";
+ }
+ leaf upper-port {
+ type inet:port-number;
+ must ". >= ../lower-port" {
+ description
+ "Upper boundary must be
+ higher than lower boundary.";
+ }
+ description
+
+ "Upper boundary for port. If it exists,
+ upper boundary must be higher than lower
+ boundary.";
+ }
+ description
+ "Match on Layer 4 dst port range. When only
+ lower-port is present, it represents a single
+ port. When both lower-port and upper-port are
+ specified, it implies a range inclusive of both
+ values.";
+ }
+ leaf protocol-field {
+ type union {
+ type uint8;
+ type identityref {
+ base protocol-type;
+ }
+ }
+ description
+ "Match on IPv4 protocol or IPv6 Next Header field.";
+ }
+ description
+ "Describes flow-matching criteria.";
+ }
+ description
+ "Flow definition based on criteria.";
+ }
+ grouping site-service-basic {
+ leaf svc-input-bandwidth {
+ type uint64;
+ units bps;
+ mandatory true;
+ description
+ "From the customer site's perspective, the service
+ input bandwidth of the connection or download
+ bandwidth from the SP to the site.";
+ }
+ leaf svc-output-bandwidth {
+ type uint64;
+ units bps;
+ mandatory true;
+ description
+ "From the customer site's perspective, the service
+ output bandwidth of the connection or upload
+ bandwidth from the site to the SP.";
+ }
+ leaf svc-mtu {
+ type uint16;
+
+ units bytes;
+ mandatory true;
+ description
+ "MTU at service level. If the service is IP,
+ it refers to the IP MTU. If CsC is enabled,
+ the requested 'svc-mtu' leaf will refer to the
+ MPLS MTU and not to the IP MTU.";
+ }
+ description
+ "Defines basic service parameters for a site.";
+ }
+ grouping site-protection {
+ container traffic-protection {
+ if-feature fast-reroute;
+ leaf enabled {
+ type boolean;
+ default false;
+ description
+ "Enables traffic protection of access link.";
+ }
+ description
+ "Fast Reroute service parameters for the site.";
+ }
+ description
+ "Defines protection service parameters for a site.";
+ }
+ grouping site-service-mpls {
+ container carrierscarrier {
+ if-feature carrierscarrier;
+ leaf signalling-type {
+ type enumeration {
+ enum ldp {
+ description
+ "Use LDP as the signalling protocol
+ between the PE and the CE. In this case,
+ an IGP routing protocol must also be activated.";
+ }
+ enum bgp {
+ description
+ "Use BGP (as per RFC 8277) as the signalling protocol
+ between the PE and the CE.
+ In this case, BGP must also be configured as
+ the routing protocol.";
+ }
+ }
+ default bgp;
+ description
+ "MPLS signalling type.";
+
+ }
+ description
+ "This container is used when the customer provides
+ MPLS-based services. This is only used in the case
+ of CsC (i.e., a customer builds an MPLS service using
+ an IP VPN to carry its traffic).";
+ }
+ description
+ "Defines MPLS service parameters for a site.";
+ }
+ grouping site-service-qos-profile {
+ container qos {
+ if-feature qos;
+ container qos-classification-policy {
+ list rule {
+ key id;
+ ordered-by user;
+ leaf id {
+ type string;
+ description
+ "A description identifying the
+ qos-classification-policy rule.";
+ }
+ choice match-type {
+ default match-flow;
+ case match-flow {
+ uses flow-definition;
+ }
+ case match-application {
+ leaf match-application {
+ type identityref {
+ base customer-application;
+ }
+ description
+ "Defines the application to match.";
+ }
+ }
+ description
+ "Choice for classification.";
+ }
+ leaf target-class-id {
+ type string;
+ description
+ "Identification of the class of service.
+ This identifier is internal to the administration.";
+ }
+ description
+ "List of marking rules.";
+
+ }
+ description
+ "Configuration of the traffic classification policy.";
+ }
+ container qos-profile {
+ choice qos-profile {
+ description
+ "Choice for QoS profile.
+ Can be standard profile or customized profile.";
+ case standard {
+ description
+ "Standard QoS profile.";
+ leaf profile {
+ type leafref {
+ path "/l3vpn-svc/vpn-profiles/valid-provider-identifiers"+
+ "/qos-profile-identifier/id";
+ }
+ description
+ "QoS profile to be used.";
+ }
+ }
+ case custom {
+ description
+ "Customized QoS profile.";
+ container classes {
+ if-feature qos-custom;
+ list class {
+ key class-id;
+ leaf class-id {
+ type string;
+ description
+ "Identification of the class of service.
+ This identifier is internal to the
+ administration.";
+ }
+ leaf direction {
+ type identityref {
+ base qos-profile-direction;
+ }
+ default both;
+ description
+ "The direction to which the QoS profile
+ is applied.";
+ }
+ leaf rate-limit {
+ type decimal64 {
+ fraction-digits 5;
+ range "0..100";
+
+ }
+ units percent;
+ description
+ "To be used if the class must be rate-limited.
+ Expressed as percentage of the service
+ bandwidth.";
+ }
+ container latency {
+ choice flavor {
+ case lowest {
+ leaf use-lowest-latency {
+ type empty;
+ description
+ "The traffic class should use the path with the
+ lowest latency.";
+ }
+ }
+ case boundary {
+ leaf latency-boundary {
+ type uint16;
+ units msec;
+ default 400;
+ description
+ "The traffic class should use a path with a
+ defined maximum latency.";
+ }
+ }
+ description
+ "Latency constraint on the traffic class.";
+ }
+ description
+ "Latency constraint on the traffic class.";
+ }
+ container jitter {
+ choice flavor {
+ case lowest {
+ leaf use-lowest-jitter {
+ type empty;
+ description
+ "The traffic class should use the path with the
+ lowest jitter.";
+ }
+ }
+ case boundary {
+ leaf latency-boundary {
+ type uint32;
+ units usec;
+ default 40000;
+
+ description
+ "The traffic class should use a path with a
+ defined maximum jitter.";
+ }
+ }
+ description
+ "Jitter constraint on the traffic class.";
+ }
+ description
+ "Jitter constraint on the traffic class.";
+ }
+ container bandwidth {
+ leaf guaranteed-bw-percent {
+ type decimal64 {
+ fraction-digits 5;
+ range "0..100";
+ }
+ units percent;
+ mandatory true;
+ description
+ "To be used to define the guaranteed bandwidth
+ as a percentage of the available service bandwidth.";
+ }
+ leaf end-to-end {
+ type empty;
+ description
+ "Used if the bandwidth reservation
+ must be done on the MPLS network too.";
+ }
+ description
+ "Bandwidth constraint on the traffic class.";
+ }
+ description
+ "List of classes of services.";
+ }
+ description
+ "Container for list of classes of services.";
+ }
+ }
+ }
+ description
+ "QoS profile configuration.";
+ }
+ description
+ "QoS configuration.";
+ }
+ description
+ "This grouping defines QoS parameters for a site.";
+
+ }
+ grouping site-security-authentication {
+ container authentication {
+ description
+ "Authentication parameters.";
+ }
+ description
+ "This grouping defines authentication parameters for a site.";
+ }
+ grouping site-security-encryption {
+ container encryption {
+ if-feature encryption;
+ leaf enabled {
+ type boolean;
+ default false;
+ description
+ "If true, traffic encryption on the connection is required.";
+ }
+ leaf layer {
+ when "../enabled = 'true'" {
+ description
+ "Require a value for layer when enabled is true.";
+ }
+ type enumeration {
+ enum layer2 {
+ description
+ "Encryption will occur at Layer 2.";
+ }
+ enum layer3 {
+ description
+ "Encryption will occur at Layer 3.
+ For example, IPsec may be used when
+ a customer requests Layer 3 encryption.";
+ }
+ }
+ description
+ "Layer on which encryption is applied.";
+ }
+ container encryption-profile {
+ choice profile {
+ case provider-profile {
+ leaf profile-name {
+ type leafref {
+ path "/l3vpn-svc/vpn-profiles/valid-provider-identifiers"+
+ "/encryption-profile-identifier/id";
+ }
+ description
+ "Name of the SP profile to be applied.";
+
+ }
+ }
+ case customer-profile {
+ leaf algorithm {
+ type string;
+ description
+ "Encryption algorithm to be used.";
+ }
+ choice key-type {
+ default psk;
+ case psk {
+ leaf preshared-key {
+ type string;
+ description
+ "Pre-Shared Key (PSK) coming from the customer.";
+ }
+ }
+ description
+ "Type of keys to be used.";
+ }
+ }
+ description
+ "Choice of encryption profile. The encryption
+ profile can be the provider profile or customer profile.";
+ }
+ description
+ "Profile of encryption to be applied.";
+ }
+ description
+ "Encryption parameters.";
+ }
+ description
+ "This grouping defines encryption parameters for a site.";
+ }
+ grouping site-attachment-bearer {
+ container bearer {
+ container requested-type {
+ if-feature requested-type;
+ leaf requested-type {
+ type string;
+ description
+ "Type of requested bearer: Ethernet, DSL,
+ Wireless, etc. Operator specific.";
+ }
+ leaf strict {
+ type boolean;
+ default false;
+ description
+
+ "Defines whether requested-type is a preference
+ or a strict requirement.";
+ }
+ description
+ "Container for requested-type.";
+ }
+ leaf always-on {
+ if-feature always-on;
+ type boolean;
+ default true;
+ description
+ "Request for an always-on access type.
+ For example, this could mean no dial access type.";
+ }
+ leaf bearer-reference {
+ if-feature bearer-reference;
+ type string;
+ description
+ "This is an internal reference for the SP.";
+ }
+ description
+ "Bearer-specific parameters.
+ To be augmented.";
+ }
+ description
+ "Defines physical properties of a site attachment.";
+ }
+ grouping site-routing {
+ container routing-protocols {
+ list routing-protocol {
+ key type;
+ leaf type {
+ type identityref {
+ base routing-protocol-type;
+ }
+ description
+ "Type of routing protocol.";
+ }
+ container ospf {
+ when "derived-from-or-self(../type, 'l3vpn-svc:ospf')" {
+ description
+ "Only applies when protocol is OSPF.";
+ }
+ if-feature rtg-ospf;
+ leaf-list address-family {
+ type address-family;
+ min-elements "1";
+ description
+
+ "If OSPF is used on this site, this node
+ contains a configured value. This node
+ contains at least one address family
+ to be activated.";
+ }
+ leaf area-address {
+ type yang:dotted-quad;
+ mandatory true;
+ description
+ "Area address.";
+ }
+ leaf metric {
+ type uint16;
+ default 1;
+ description
+ "Metric of the PE-CE link. It is used
+ in the routing state calculation and
+ path selection.";
+ }
+ container sham-links {
+ if-feature rtg-ospf-sham-link;
+ list sham-link {
+ key target-site;
+ leaf target-site {
+ type svc-id;
+ description
+ "Target site for the sham link connection.
+ The site is referred to by its ID.";
+ }
+ leaf metric {
+ type uint16;
+ default 1;
+ description
+ "Metric of the sham link. It is used in
+ the routing state calculation and path
+ selection. The default value is set
+ to 1.";
+ }
+ description
+ "Creates a sham link with another site.";
+ }
+ description
+ "List of sham links.";
+ }
+ description
+ "OSPF-specific configuration.";
+ }
+ container bgp {
+
+ when "derived-from-or-self(../type, 'l3vpn-svc:bgp')" {
+ description
+ "Only applies when protocol is BGP.";
+ }
+ if-feature rtg-bgp;
+ leaf autonomous-system {
+ type uint32;
+ mandatory true;
+ description
+ "Customer AS number in case the customer
+ requests BGP routing.";
+ }
+ leaf-list address-family {
+ type address-family;
+ min-elements "1";
+ description
+ "If BGP is used on this site, this node
+ contains a configured value. This node
+ contains at least one address family
+ to be activated.";
+ }
+ description
+ "BGP-specific configuration.";
+ }
+ container static {
+ when "derived-from-or-self(../type, 'l3vpn-svc:static')" {
+ description
+ "Only applies when protocol is static.
+ BGP activation requires the SP to know
+ the address of the customer peer. When
+ BGP is enabled, the 'static-address'
+ allocation type for the IP connection
+ MUST be used.";
+ }
+ container cascaded-lan-prefixes {
+ list ipv4-lan-prefixes {
+ if-feature ipv4;
+ key "lan next-hop";
+ leaf lan {
+ type inet:ipv4-prefix;
+ description
+ "LAN prefixes.";
+ }
+ leaf lan-tag {
+ type string;
+ description
+ "Internal tag to be used in VPN policies.";
+ }
+
+ leaf next-hop {
+ type inet:ipv4-address;
+ description
+ "Next-hop address to use on the customer side.";
+ }
+ description
+ "List of LAN prefixes for the site.";
+ }
+ list ipv6-lan-prefixes {
+ if-feature ipv6;
+ key "lan next-hop";
+ leaf lan {
+ type inet:ipv6-prefix;
+ description
+ "LAN prefixes.";
+ }
+ leaf lan-tag {
+ type string;
+ description
+ "Internal tag to be used in VPN policies.";
+ }
+ leaf next-hop {
+ type inet:ipv6-address;
+ description
+ "Next-hop address to use on the customer side.";
+ }
+ description
+ "List of LAN prefixes for the site.";
+ }
+ description
+ "LAN prefixes from the customer.";
+ }
+ description
+ "Configuration specific to static routing.";
+ }
+ container rip {
+ when "derived-from-or-self(../type, 'l3vpn-svc:rip')" {
+ description
+ "Only applies when the protocol is RIP. For IPv4,
+ the model assumes that RIP version 2 is used.";
+ }
+ if-feature rtg-rip;
+ leaf-list address-family {
+ type address-family;
+ min-elements "1";
+ description
+ "If RIP is used on this site, this node
+ contains a configured value. This node
+
+ contains at least one address family
+ to be activated.";
+ }
+ description
+ "Configuration specific to RIP routing.";
+ }
+ container vrrp {
+ when "derived-from-or-self(../type, 'l3vpn-svc:vrrp')" {
+ description
+ "Only applies when protocol is VRRP.";
+ }
+ if-feature rtg-vrrp;
+ leaf-list address-family {
+ type address-family;
+ min-elements "1";
+ description
+ "If VRRP is used on this site, this node
+ contains a configured value. This node contains
+ at least one address family to be activated.";
+ }
+ description
+ "Configuration specific to VRRP routing.";
+ }
+ description
+ "List of routing protocols used on
+ the site. This list can be augmented.";
+ }
+ description
+ "Defines routing protocols.";
+ }
+ description
+ "Grouping for routing protocols.";
+ }
+ grouping site-attachment-ip-connection {
+ container ip-connection {
+ container ipv4 {
+ if-feature ipv4;
+ leaf address-allocation-type {
+ type identityref {
+ base address-allocation-type;
+ }
+ must "not(derived-from-or-self(current(), 'l3vpn-svc:slaac') or "+
+ "derived-from-or-self(current(), "+
+ "'l3vpn-svc:provider-dhcp-slaac'))" {
+ error-message "SLAAC is only applicable to IPv6";
+ }
+ description
+ "Defines how addresses are allocated.
+
+ If there is no value for the address
+ allocation type, then IPv4 is not enabled.";
+ }
+ container provider-dhcp {
+ when "derived-from-or-self(../address-allocation-type, "+
+ "'l3vpn-svc:provider-dhcp')" {
+ description
+ "Only applies when addresses are allocated by DHCP.";
+ }
+ leaf provider-address {
+ type inet:ipv4-address;
+ description
+ "Address of provider side. If provider-address is not
+ specified, then prefix length should not be specified
+ either. It also implies provider-dhcp allocation is
+ not enabled. If provider-address is specified, then
+ the prefix length may or may not be specified.";
+ }
+ leaf prefix-length {
+ type uint8 {
+ range "0..32";
+ }
+ must "(../provider-address)" {
+ error-message
+ "If the prefix length is specified, provider-address
+ must also be specified.";
+ description
+ "If the prefix length is specified, provider-address
+ must also be specified.";
+ }
+ description
+ "Subnet prefix length expressed in bits.
+ If not specified, or specified as zero,
+ this means the customer leaves the actual
+ prefix length value to the provider.";
+ }
+ choice address-assign {
+ default number;
+ case number {
+ leaf number-of-dynamic-address {
+ type uint16;
+ default 1;
+ description
+ "Describes the number of IP addresses
+ the customer requires.";
+ }
+ }
+ case explicit {
+
+ container customer-addresses {
+ list address-group {
+ key "group-id";
+ leaf group-id {
+ type string;
+ description
+ "Group-id for the address range from
+ start-address to end-address.";
+ }
+ leaf start-address {
+ type inet:ipv4-address;
+ description
+ "First address.";
+ }
+ leaf end-address {
+ type inet:ipv4-address;
+ description
+ "Last address.";
+ }
+ description
+ "Describes IP addresses allocated by DHCP.
+ When only start-address or only end-address
+ is present, it represents a single address.
+ When both start-address and end-address are
+ specified, it implies a range inclusive of both
+ addresses. If no address is specified, it implies
+ customer addresses group is not supported.";
+ }
+ description
+ "Container for customer addresses is allocated by DHCP.";
+ }
+ }
+ description
+ "Choice for the way to assign addresses.";
+ }
+ description
+ "DHCP allocated addresses related parameters.";
+ }
+ container dhcp-relay {
+ when "derived-from-or-self(../address-allocation-type, "+
+ "'l3vpn-svc:provider-dhcp-relay')" {
+ description
+ "Only applies when provider is required to implement
+ DHCP relay function.";
+ }
+ leaf provider-address {
+ type inet:ipv4-address;
+ description
+
+ "Address of provider side. If provider-address is not
+ specified, then prefix length should not be specified
+ either. It also implies provider-dhcp allocation is
+ not enabled. If provider-address is specified, then
+ prefix length may or may not be specified.";
+ }
+ leaf prefix-length {
+ type uint8 {
+ range "0..32";
+ }
+ must "(../provider-address)" {
+ error-message
+ "If prefix length is specified, provider-address
+ must also be specified.";
+ description
+ "If prefix length is specified, provider-address
+ must also be specified.";
+ }
+ description
+ "Subnet prefix length expressed in bits. If not
+ specified, or specified as zero, this means the
+ customer leaves the actual prefix length value
+ to the provider.";
+ }
+ container customer-dhcp-servers {
+ leaf-list server-ip-address {
+ type inet:ipv4-address;
+ description
+ "IP address of customer DHCP server.";
+ }
+ description
+ "Container for list of customer DHCP servers.";
+ }
+ description
+ "DHCP relay provided by operator.";
+ }
+ container addresses {
+ when "derived-from-or-self(../address-allocation-type, "+
+ "'l3vpn-svc:static-address')" {
+ description
+ "Only applies when protocol allocation type is static.";
+ }
+ leaf provider-address {
+ type inet:ipv4-address;
+ description
+ "IPv4 Address List of the provider side.
+ When the protocol allocation type is static,
+ the provider address must be configured.";
+
+ }
+ leaf customer-address {
+ type inet:ipv4-address;
+ description
+ "IPv4 Address of customer side.";
+ }
+ leaf prefix-length {
+ type uint8 {
+ range "0..32";
+ }
+ description
+ "Subnet prefix length expressed in bits.
+ It is applied to both provider-address
+ and customer-address.";
+ }
+ description
+ "Describes IPv4 addresses used.";
+ }
+ description
+ "IPv4-specific parameters.";
+ }
+ container ipv6 {
+ if-feature ipv6;
+ leaf address-allocation-type {
+ type identityref {
+ base address-allocation-type;
+ }
+ description
+ "Defines how addresses are allocated.
+ If there is no value for the address
+ allocation type, then IPv6 is
+ not enabled.";
+ }
+
+ container provider-dhcp {
+ when "derived-from-or-self(../address-allocation-type, "+
+ "'l3vpn-svc:provider-dhcp') "+
+ "or derived-from-or-self(../address-allocation-type, "+
+ "'l3vpn-svc:provider-dhcp-slaac')" {
+ description
+ "Only applies when addresses are allocated by DHCP.";
+ }
+ leaf provider-address {
+ type inet:ipv6-address;
+ description
+ "Address of the provider side. If provider-address
+ is not specified, then prefix length should not be
+ specified either. It also implies provider-dhcp
+
+ allocation is not enabled. If provider-address is
+ specified, then prefix length may or may
+ not be specified.";
+ }
+ leaf prefix-length {
+ type uint8 {
+ range "0..128";
+ }
+ must "(../provider-address)" {
+ error-message
+ "If prefix length is specified, provider-address
+ must also be specified.";
+ description
+ "If prefix length is specified, provider-address
+ must also be specified.";
+ }
+ description
+ "Subnet prefix length expressed in bits. If not
+ specified, or specified as zero, this means the
+ customer leaves the actual prefix length value
+ to the provider.";
+ }
+ choice address-assign {
+ default number;
+ case number {
+ leaf number-of-dynamic-address {
+ type uint16;
+ default 1;
+ description
+ "Describes the number of IP addresses the customer
+ requires.";
+ }
+ }
+ case explicit {
+ container customer-addresses {
+ list address-group {
+ key "group-id";
+ leaf group-id {
+ type string;
+ description
+ "Group-id for the address range from
+ start-address to end-address.";
+ }
+ leaf start-address {
+ type inet:ipv6-address;
+ description
+ "First address.";
+ }
+
+ leaf end-address {
+ type inet:ipv6-address;
+ description
+ "Last address.";
+ }
+ description
+ "Describes IP addresses allocated by DHCP. When only
+ start-address or only end-address is present, it
+ represents a single address. When both start-address
+ and end-address are specified, it implies a range
+ inclusive of both addresses. If no address is
+ specified, it implies customer addresses group is
+ not supported.";
+ }
+ description
+ "Container for customer addresses allocated by DHCP.";
+ }
+ }
+ description
+ "Choice for the way to assign addresses.";
+ }
+ description
+ "DHCP allocated addresses related parameters.";
+ }
+ container dhcp-relay {
+ when "derived-from-or-self(../address-allocation-type, "+
+ "'l3vpn-svc:provider-dhcp-relay')" {
+ description
+ "Only applies when the provider is required
+ to implement DHCP relay function.";
+ }
+ leaf provider-address {
+ type inet:ipv6-address;
+ description
+ "Address of the provider side. If provider-address is
+ not specified, then prefix length should not be
+ specified either. It also implies provider-dhcp
+ allocation is not enabled. If provider address
+ is specified, then prefix length may or may
+ not be specified.";
+ }
+ leaf prefix-length {
+ type uint8 {
+ range "0..128";
+ }
+ must "(../provider-address)" {
+ error-message
+ "If prefix length is specified, provider-address
+
+ must also be specified.";
+ description
+ "If prefix length is specified, provider-address
+ must also be specified.";
+ }
+ description
+ "Subnet prefix length expressed in bits. If not
+ specified, or specified as zero, this means the
+ customer leaves the actual prefix length value
+ to the provider.";
+ }
+ container customer-dhcp-servers {
+ leaf-list server-ip-address {
+ type inet:ipv6-address;
+ description
+ "This node contains the IP address of
+ the customer DHCP server. If the DHCP relay
+ function is implemented by the
+ provider, this node contains the
+ configured value.";
+ }
+ description
+ "Container for list of customer DHCP servers.";
+ }
+ description
+ "DHCP relay provided by operator.";
+ }
+ container addresses {
+ when "derived-from-or-self(../address-allocation-type, "+
+ "'l3vpn-svc:static-address')" {
+ description
+ "Only applies when protocol allocation type is static.";
+ }
+ leaf provider-address {
+ type inet:ipv6-address;
+ description
+ "IPv6 Address of the provider side. When the protocol
+ allocation type is static, the provider address
+ must be configured.";
+ }
+ leaf customer-address {
+ type inet:ipv6-address;
+ description
+ "The IPv6 Address of the customer side.";
+ }
+ leaf prefix-length {
+ type uint8 {
+ range "0..128";
+
+ }
+ description
+ "Subnet prefix length expressed in bits.
+ It is applied to both provider-address and
+ customer-address.";
+ }
+ description
+ "Describes IPv6 addresses used.";
+ }
+ description
+ "IPv6-specific parameters.";
+ }
+ container oam {
+ container bfd {
+ if-feature bfd;
+ leaf enabled {
+ type boolean;
+ default false;
+ description
+ "If true, BFD activation is required.";
+ }
+ choice holdtime {
+ default fixed;
+ case fixed {
+ leaf fixed-value {
+ type uint32;
+ units msec;
+ description
+ "Expected BFD holdtime expressed in msec. The customer
+ may impose some fixed values for the holdtime period
+ if the provider allows the customer use this function.
+ If the provider doesn't allow the customer to use this
+ function, the fixed-value will not be set.";
+ }
+ }
+ case profile {
+ leaf profile-name {
+ type leafref {
+ path "/l3vpn-svc/vpn-profiles/valid-provider-identifiers/"+
+ "bfd-profile-identifier/id";
+ }
+ description
+ "Well-known SP profile name. The provider can propose
+ some profiles to the customer, depending on the service
+ level the customer wants to achieve. Profile names
+ must be communicated to the customer.";
+ }
+ description
+
+ "Well-known SP profile.";
+ }
+ description
+ "Choice for holdtime flavor.";
+ }
+ description
+ "Container for BFD.";
+ }
+ description
+ "Defines the Operations, Administration, and Maintenance (OAM)
+ mechanisms used on the connection. BFD is set as a fault
+ detection mechanism, but the 'oam' container can easily
+ be augmented by other mechanisms";
+ }
+ description
+ "Defines connection parameters.";
+ }
+ description
+ "This grouping defines IP connection parameters.";
+ }
+ grouping site-service-multicast {
+ container multicast {
+ if-feature multicast;
+ leaf multicast-site-type {
+ type enumeration {
+ enum receiver-only {
+ description
+ "The site only has receivers.";
+ }
+ enum source-only {
+ description
+ "The site only has sources.";
+ }
+ enum source-receiver {
+ description
+ "The site has both sources and receivers.";
+ }
+ }
+ default source-receiver;
+ description
+ "Type of multicast site.";
+ }
+ container multicast-address-family {
+ leaf ipv4 {
+ if-feature ipv4;
+ type boolean;
+ default false;
+ description
+
+ "Enables IPv4 multicast.";
+ }
+ leaf ipv6 {
+ if-feature ipv6;
+ type boolean;
+ default false;
+ description
+ "Enables IPv6 multicast.";
+ }
+ description
+ "Defines protocol to carry multicast.";
+ }
+ leaf protocol-type {
+ type enumeration {
+ enum host {
+ description
+ "Hosts are directly connected to the provider network.
+ Host protocols such as IGMP or MLD are required.";
+ }
+ enum router {
+ description
+ "Hosts are behind a customer router.
+ PIM will be implemented.";
+ }
+ enum both {
+ description
+ "Some hosts are behind a customer router, and
+ some others are directly connected to the
+ provider network. Both host and routing protocols
+ must be used. Typically, IGMP and PIM will be
+ implemented.";
+ }
+ }
+ default "both";
+ description
+ "Multicast protocol type to be used with the customer site.";
+ }
+ description
+ "Multicast parameters for the site.";
+ }
+ description
+ "Multicast parameters for the site.";
+ }
+ grouping site-management {
+ container management {
+ leaf type {
+ type identityref {
+ base management;
+
+ }
+ mandatory true;
+ description
+ "Management type of the connection.";
+ }
+ description
+ "Management configuration.";
+ }
+ description
+ "Management parameters for the site.";
+ }
+ grouping site-devices {
+ container devices {
+ when "derived-from-or-self(../management/type, "+
+ "'l3vpn-svc:provider-managed') or "+
+ "derived-from-or-self(../management/type, 'l3vpn-svc:co-managed')" {
+ description
+ "Applicable only for provider-managed or
+ co-managed device.";
+ }
+ list device {
+ key device-id;
+ leaf device-id {
+ type svc-id;
+ description
+ "Identifier for the device.";
+ }
+ leaf location {
+ type leafref {
+ path "../../../locations/"+
+ "location/location-id";
+ }
+ mandatory true;
+ description
+ "Location of the device.";
+ }
+ container management {
+ when "derived-from-or-self(../../../management/type,"+
+ "'l3vpn-svc:co-managed')" {
+ description
+ "Applicable only for co-managed device.";
+ }
+ leaf address-family {
+ type address-family;
+ description
+ "Address family used for management.";
+ }
+ leaf address {
+
+ when "(../address-family)" {
+ description
+ "If address-family is specified, then address should
+ also be specified. If address-family is not specified,
+ then address should also not be specified.";
+ }
+ type inet:ip-address;
+ mandatory true;
+ description
+ "Management address.";
+ }
+ description
+ "Management configuration. Applicable only for
+ co-managed device.";
+ }
+ description
+ "List of devices requested by customer.";
+ }
+ description
+ "Device configuration.";
+ }
+ description
+ "Grouping for device allocation.";
+ }
+ grouping site-vpn-flavor {
+ leaf site-vpn-flavor {
+ type identityref {
+ base site-vpn-flavor;
+ }
+ default site-vpn-flavor-single;
+ description
+ "Defines the way the VPN multiplexing is done, e.g., whether
+ the site belongs to a single VPN site or a multiVPN; or, in the case
+ of a multiVPN, whether the logical accesses of the sites belong
+ to the same set of VPNs or each logical access maps to
+ different VPNs.";
+ }
+ description
+ "Grouping for site VPN flavor.";
+ }
+ grouping site-vpn-policy {
+ container vpn-policies {
+ list vpn-policy {
+ key vpn-policy-id;
+ leaf vpn-policy-id {
+ type svc-id;
+ description
+ "Unique identifier for the VPN policy.";
+
+ }
+ list entries {
+ key id;
+ leaf id {
+ type svc-id;
+ description
+ "Unique identifier for the policy entry.";
+ }
+ container filters {
+ list filter {
+ key type;
+ ordered-by user;
+ leaf type {
+ type identityref {
+ base vpn-policy-filter-type;
+ }
+ description
+ "Type of VPN Policy filter.";
+ }
+ leaf-list lan-tag {
+ when "derived-from-or-self(../type, 'l3vpn-svc:lan')" {
+ description
+ "Only applies when the VPN Policy filter is a
+ LAN Tag filter.";
+ }
+ if-feature lan-tag;
+ type string;
+ description
+ "List of 'lan-tag' items to be matched. LAN Tag
+ is an Internal tag to be used in VPN policies ";
+ }
+ leaf-list ipv4-lan-prefix {
+ when "derived-from-or-self(../type, 'l3vpn-svc:ipv4')" {
+ description
+ "Only applies when VPN Policy filter is IPv4 Prefix filter.";
+ }
+ if-feature ipv4;
+ type inet:ipv4-prefix;
+ description
+ "List of IPv4 prefixes as LAN Prefixes to be matched.";
+ }
+ leaf-list ipv6-lan-prefix {
+ when "derived-from-or-self(../type, 'l3vpn-svc:ipv6')" {
+ description
+ "Only applies when VPN Policy filter is IPv6 Prefix filter.";
+ }
+ if-feature ipv6;
+ type inet:ipv6-prefix;
+
+ description
+ "List of IPv6 prefixes as LAN prefixes to be matched.";
+ }
+ description
+ "List of filters used on the site. This list can
+ be augmented.";
+ }
+ description
+ "If a more-granular VPN attachment is necessary, filtering can
+ be used. If used, it permits the splitting of site LANs among
+ multiple VPNs. The Site LAN can be split based on either LAN
+ Tag or LAN prefix. If no filter is used, all the LANs will be
+ part of the same VPNs with the same role.";
+ }
+ list vpn {
+ key vpn-id;
+ leaf vpn-id {
+ type leafref {
+ path "/l3vpn-svc/vpn-services/"+
+ "vpn-service/vpn-id";
+ }
+ mandatory true;
+ description
+ "Reference to an IP VPN.";
+ }
+ leaf site-role {
+ type identityref {
+ base site-role;
+ }
+ default any-to-any-role;
+ description
+ "Role of the site in the IP VPN.";
+ }
+ description
+ "List of VPNs the LAN is associated with.";
+ }
+ description
+ "List of entries for export policy.";
+ }
+ description
+ "List of VPN policies.";
+ }
+ description
+ "VPN policy.";
+ }
+ description
+ "VPN policy parameters for the site.";
+ }
+
+ grouping site-maximum-routes {
+ container maximum-routes {
+ list address-family {
+ key af;
+ leaf af {
+ type address-family;
+ description
+ "Address family.";
+ }
+ leaf maximum-routes {
+ type uint32;
+ description
+ "Maximum prefixes the VRF can accept
+ for this address family.";
+ }
+ description
+ "List of address families.";
+ }
+ description
+ "Defines 'maximum-routes' for the VRF.";
+ }
+ description
+ "Defines 'maximum-routes' for the site.";
+ }
+ grouping site-security {
+ container security {
+ uses site-security-authentication;
+ uses site-security-encryption;
+ description
+ "Site-specific security parameters.";
+ }
+ description
+ "Grouping for security parameters.";
+ }
+ grouping site-service {
+ container service {
+ uses site-service-qos-profile;
+ uses site-service-mpls;
+ uses site-service-multicast;
+ description
+ "Service parameters on the attachment.";
+ }
+ description
+ "Grouping for service parameters.";
+ }
+ grouping site-network-access-service {
+ container service {
+ uses site-service-basic;
+
+ uses site-service-qos-profile;
+ uses site-service-mpls;
+ uses site-service-multicast;
+ description
+ "Service parameters on the attachment.";
+ }
+ description
+ "Grouping for service parameters.";
+ }
+ grouping vpn-extranet {
+ container extranet-vpns {
+ if-feature extranet-vpn;
+ list extranet-vpn {
+ key vpn-id;
+ leaf vpn-id {
+ type svc-id;
+ description
+ "Identifies the target VPN the local VPN want to access.";
+ }
+ leaf local-sites-role {
+ type identityref {
+ base site-role;
+ }
+ default any-to-any-role;
+ description
+ "This describes the role of the
+ local sites in the target VPN topology. In the any-to-any VPN
+ service topology, the local sites must have the same role, which
+ will be 'any-to-any-role'. In the Hub-and-Spoke VPN service
+ topology or the Hub-and-Spoke disjoint VPN service topology,
+ the local sites must have a Hub role or a Spoke role.";
+ }
+ description
+ "List of extranet VPNs or target VPNs the local VPN is
+ attached to.";
+ }
+ description
+ "Container for extranet VPN configuration.";
+ }
+ description
+ "Grouping for extranet VPN configuration.
+ This provides an easy way to interconnect
+ all sites from two VPNs.";
+ }
+ grouping site-attachment-availability {
+ container availability {
+ leaf access-priority {
+ type uint32;
+
+ default 100;
+ description
+ "Defines the priority for the access.
+ The higher the access-priority value,
+ the higher the preference of the
+ access will be.";
+ }
+ description
+ "Availability parameters (used for multihoming).";
+ }
+ description
+ "Defines availability parameters for a site.";
+ }
+ grouping access-vpn-policy {
+ container vpn-attachment {
+ choice attachment-flavor {
+ case vpn-policy-id {
+ leaf vpn-policy-id {
+ type leafref {
+ path "../../../../"+
+ "vpn-policies/vpn-policy/"+
+ "vpn-policy-id";
+ }
+ description
+ "Reference to a VPN policy. When referencing VPN
+ policy for attachment, the vpn-policy-id must be
+ configured.";
+ }
+ }
+ case vpn-id {
+ leaf vpn-id {
+ type leafref {
+ path "/l3vpn-svc/vpn-services"+
+ "/vpn-service/vpn-id";
+ }
+ description
+ "Reference to an IP VPN. Referencing a vpn-id provides
+ an easy way to attach a particular logical access to
+ a VPN. In this case, vpn-id must be configured.";
+ }
+ leaf site-role {
+ type identityref {
+ base site-role;
+ }
+ default any-to-any-role;
+ description
+ "Role of the site in the IP VPN. When referencing a vpn-id,
+ the site-role setting must be added to express the role of
+
+ the site in the target VPN service topology.";
+ }
+ }
+ mandatory true;
+ description
+ "Choice for VPN attachment flavor. A choice is implemented
+ to allow the user to choose the flavor that provides the
+ best fit.";
+ }
+ description
+ "Defines VPN attachment of a site.";
+ }
+ description
+ "Defines the VPN attachment rules for
+ a site's logical access.";
+ }
+ grouping vpn-profile-cfg {
+ container valid-provider-identifiers {
+ list cloud-identifier {
+ if-feature cloud-access;
+ key id;
+ leaf id {
+ type string;
+ description
+ "Identification of cloud service.
+ Local administration meaning.";
+ }
+ description
+ "List for Cloud Identifiers.";
+ }
+ list encryption-profile-identifier {
+ key id;
+ leaf id {
+ type string;
+ description
+ "Identification of the SP encryption profile
+ to be used. Local administration meaning.";
+ }
+ description
+ "List for encryption profile identifiers.";
+ }
+ list qos-profile-identifier {
+ key id;
+ leaf id {
+ type string;
+ description
+ "Identification of the QoS Profile to be used.
+ Local administration meaning.";
+
+ }
+ description
+ "List for QoS Profile Identifiers.";
+ }
+ list bfd-profile-identifier {
+ key id;
+ leaf id {
+ type string;
+ description
+ "Identification of the SP BFD Profile to be used.
+ Local administration meaning.";
+ }
+ description
+ "List for BFD Profile identifiers.";
+ }
+ nacm:default-deny-write;
+ description
+ "Container for Valid Provider Identifies.";
+ }
+ description
+ "Grouping for VPN Profile configuration.";
+ }
+ grouping vpn-svc-cfg {
+ leaf vpn-id {
+ type svc-id;
+ description
+ "VPN identifier. Local administration meaning.";
+ }
+ leaf customer-name {
+ type string;
+ description
+ "Name of the customer that actually uses the VPN service.
+ In the case that any intermediary (e.g., Tier-2 provider
+ or partner) sells the VPN service to their end user
+ on behalf of the original service provider (e.g., Tier-1
+ provider), the original service provider may require the
+ customer name to provide smooth activation/commissioning
+ and operation for the service.";
+ }
+ leaf vpn-service-topology {
+ type identityref {
+ base vpn-topology;
+ }
+ default any-to-any;
+ description
+ "VPN service topology.";
+ }
+ uses vpn-service-cloud-access;
+
+ uses vpn-service-multicast;
+ uses vpn-service-mpls;
+ uses vpn-extranet;
+ description
+ "Grouping for VPN service configuration.";
+ }
+ grouping site-top-level-cfg {
+ uses operational-requirements;
+ uses customer-location-info;
+ uses site-devices;
+ uses site-diversity;
+ uses site-management;
+ uses site-vpn-policy;
+ uses site-vpn-flavor;
+ uses site-maximum-routes;
+ uses site-security;
+ uses site-service;
+ uses site-protection;
+ uses site-routing;
+ description
+ "Grouping for site top-level configuration.";
+ }
+ grouping site-network-access-top-level-cfg {
+ leaf site-network-access-type {
+ type identityref {
+ base site-network-access-type;
+ }
+ default point-to-point;
+ description
+ "Describes the type of connection, e.g.,
+ point-to-point or multipoint.";
+ }
+ choice location-flavor {
+ case location {
+ when "derived-from-or-self(../../management/type, "+
+ "'l3vpn-svc:customer-managed')" {
+ description
+ "Applicable only for customer-managed device.";
+ }
+ leaf location-reference {
+ type leafref {
+ path "../../../locations/location/location-id";
+ }
+ description
+ "Location of the site-network-access.";
+ }
+ }
+ case device {
+
+ when "derived-from-or-self(../../management/type, "+
+ "'l3vpn-svc:provider-managed') or "+
+ "derived-from-or-self(../../management/type, "+
+ "'l3vpn-svc:co-managed')" {
+ description
+ "Applicable only for provider-managed or co-managed device.";
+ }
+ leaf device-reference {
+ type leafref {
+ path "../../../devices/device/device-id";
+ }
+ description
+ "Identifier of CE to use.";
+ }
+ }
+ mandatory true;
+ description
+ "Choice of how to describe the site's location.";
+ }
+ uses access-diversity;
+ uses site-attachment-bearer;
+ uses site-attachment-ip-connection;
+ uses site-security;
+ uses site-network-access-service;
+ uses site-routing;
+ uses site-attachment-availability;
+ uses access-vpn-policy;
+ description
+ "Grouping for site network access top-level configuration.";
+ }
+ /* Main blocks */
+ container l3vpn-svc {
+ container vpn-profiles {
+ uses vpn-profile-cfg;
+ description
+ "Container for VPN Profiles.";
+ }
+ container vpn-services {
+ list vpn-service {
+ key vpn-id;
+ uses vpn-svc-cfg;
+ description
+ "List of VPN services.";
+ }
+ description
+ "Top-level container for the VPN services.";
+ }
+ container sites {
+ list site {
+ key site-id;
+ leaf site-id {
+ type svc-id;
+ description
+ "Identifier of the site.";
+ }
+ uses site-top-level-cfg;
+ uses operational-requirements-ops;
+ container site-network-accesses {
+ list site-network-access {
+ key site-network-access-id;
+ leaf site-network-access-id {
+ type svc-id;
+ description
+ "Identifier for the access.";
+ }
+ uses site-network-access-top-level-cfg;
+ description
+ "List of accesses for a site.";
+ }
+ description
+ "List of accesses for a site.";
+ }
+ description
+ "List of sites.";
+ }
+ description
+ "Container for sites.";
+ }
+ description
+ "Main container for L3VPN service configuration.";
+ }
+ }
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-netconf-acm@2018-02-14.yang b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-netconf-acm@2018-02-14.yang
new file mode 100644
index 0000000000000000000000000000000000000000..dc0deb8ffd29791ad80b9e3ad8244502126f2d44
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-netconf-acm@2018-02-14.yang
@@ -0,0 +1,468 @@
+module ietf-netconf-acm {
+
+ namespace "urn:ietf:params:xml:ns:yang:ietf-netconf-acm";
+
+ prefix nacm;
+
+ import ietf-yang-types {
+ prefix yang;
+ }
+
+ organization
+ "IETF NETCONF (Network Configuration) Working Group";
+
+ contact
+ "WG Web: <https://datatracker.ietf.org/wg/netconf/>
+ WG List: <mailto:netconf@ietf.org>
+
+ Author: Andy Bierman
+ <mailto:andy@yumaworks.com>
+
+ Author: Martin Bjorklund
+ <mailto:mbj@tail-f.com>";
+
+ description
+ "Network Configuration Access Control Model.
+
+ Copyright (c) 2012 - 2018 IETF Trust and the persons
+ identified as authors of the code. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or
+ without modification, is permitted pursuant to, and subject
+ to the license terms contained in, the Simplified BSD
+ License set forth in Section 4.c of the IETF Trust's
+ Legal Provisions Relating to IETF Documents
+ (https://trustee.ietf.org/license-info).
+
+ This version of this YANG module is part of RFC 8341; see
+ the RFC itself for full legal notices.";
+
+ revision "2018-02-14" {
+ description
+ "Added support for YANG 1.1 actions and notifications tied to
+ data nodes. Clarified how NACM extensions can be used by
+ other data models.";
+ reference
+ "RFC 8341: Network Configuration Access Control Model";
+ }
+
+ revision "2012-02-22" {
+ description
+ "Initial version.";
+ reference
+ "RFC 6536: Network Configuration Protocol (NETCONF)
+ Access Control Model";
+ }
+
+ /*
+ * Extension statements
+ */
+
+ extension default-deny-write {
+ description
+ "Used to indicate that the data model node
+ represents a sensitive security system parameter.
+
+ If present, the NETCONF server will only allow the designated
+ 'recovery session' to have write access to the node. An
+ explicit access control rule is required for all other users.
+
+ If the NACM module is used, then it must be enabled (i.e.,
+ /nacm/enable-nacm object equals 'true'), or this extension
+ is ignored.
+
+ The 'default-deny-write' extension MAY appear within a data
+ definition statement. It is ignored otherwise.";
+ }
+
+ extension default-deny-all {
+ description
+ "Used to indicate that the data model node
+ controls a very sensitive security system parameter.
+
+ If present, the NETCONF server will only allow the designated
+ 'recovery session' to have read, write, or execute access to
+ the node. An explicit access control rule is required for all
+ other users.
+
+ If the NACM module is used, then it must be enabled (i.e.,
+ /nacm/enable-nacm object equals 'true'), or this extension
+ is ignored.
+
+ The 'default-deny-all' extension MAY appear within a data
+ definition statement, 'rpc' statement, or 'notification'
+ statement. It is ignored otherwise.";
+ }
+
+ /*
+ * Derived types
+ */
+
+ typedef user-name-type {
+ type string {
+ length "1..max";
+ }
+ description
+ "General-purpose username string.";
+ }
+
+ typedef matchall-string-type {
+ type string {
+ pattern '\*';
+ }
+ description
+ "The string containing a single asterisk '*' is used
+ to conceptually represent all possible values
+ for the particular leaf using this data type.";
+ }
+
+ typedef access-operations-type {
+ type bits {
+ bit create {
+ description
+ "Any protocol operation that creates a
+ new data node.";
+ position 0;
+ }
+ bit read {
+ description
+ "Any protocol operation or notification that
+ returns the value of a data node.";
+ position 1;
+ }
+ bit update {
+ description
+ "Any protocol operation that alters an existing
+ data node.";
+ position 2;
+ }
+ bit delete {
+ description
+ "Any protocol operation that removes a data node.";
+ position 3;
+ }
+ bit exec {
+ description
+ "Execution access to the specified protocol operation.";
+ position 4;
+ }
+ }
+ description
+ "Access operation.";
+ }
+
+ typedef group-name-type {
+ type string {
+ length "1..max";
+ pattern '[^\*].*';
+ }
+ description
+ "Name of administrative group to which
+ users can be assigned.";
+ }
+
+ typedef action-type {
+ type enumeration {
+ enum permit {
+ description
+ "Requested action is permitted.";
+ }
+ enum deny {
+ description
+ "Requested action is denied.";
+ }
+ }
+ description
+ "Action taken by the server when a particular
+ rule matches.";
+ }
+
+ typedef node-instance-identifier {
+ type yang:xpath1.0;
+ description
+ "Path expression used to represent a special
+ data node, action, or notification instance-identifier
+ string.
+
+ A node-instance-identifier value is an
+ unrestricted YANG instance-identifier expression.
+ All the same rules as an instance-identifier apply,
+ except that predicates for keys are optional. If a key
+ predicate is missing, then the node-instance-identifier
+ represents all possible server instances for that key.
+
+ This XML Path Language (XPath) expression is evaluated in the
+ following context:
+
+ o The set of namespace declarations are those in scope on
+ the leaf element where this type is used.
+
+ o The set of variable bindings contains one variable,
+ 'USER', which contains the name of the user of the
+ current session.
+
+ o The function library is the core function library, but
+ note that due to the syntax restrictions of an
+ instance-identifier, no functions are allowed.
+
+ o The context node is the root node in the data tree.
+
+ The accessible tree includes actions and notifications tied
+ to data nodes.";
+ }
+
+ /*
+ * Data definition statements
+ */
+
+ container nacm {
+ nacm:default-deny-all;
+
+ description
+ "Parameters for NETCONF access control model.";
+
+ leaf enable-nacm {
+ type boolean;
+ default "true";
+ description
+ "Enables or disables all NETCONF access control
+ enforcement. If 'true', then enforcement
+ is enabled. If 'false', then enforcement
+ is disabled.";
+ }
+
+ leaf read-default {
+ type action-type;
+ default "permit";
+ description
+ "Controls whether read access is granted if
+ no appropriate rule is found for a
+ particular read request.";
+ }
+
+ leaf write-default {
+ type action-type;
+ default "deny";
+ description
+ "Controls whether create, update, or delete access
+ is granted if no appropriate rule is found for a
+ particular write request.";
+ }
+
+ leaf exec-default {
+ type action-type;
+ default "permit";
+ description
+ "Controls whether exec access is granted if no appropriate
+ rule is found for a particular protocol operation request.";
+ }
+
+ leaf enable-external-groups {
+ type boolean;
+ default "true";
+ description
+ "Controls whether the server uses the groups reported by the
+ NETCONF transport layer when it assigns the user to a set of
+ NACM groups. If this leaf has the value 'false', any group
+ names reported by the transport layer are ignored by the
+ server.";
+ }
+
+ leaf denied-operations {
+ type yang:zero-based-counter32;
+ config false;
+ mandatory true;
+ description
+ "Number of times since the server last restarted that a
+ protocol operation request was denied.";
+ }
+
+ leaf denied-data-writes {
+ type yang:zero-based-counter32;
+ config false;
+ mandatory true;
+ description
+ "Number of times since the server last restarted that a
+ protocol operation request to alter
+ a configuration datastore was denied.";
+ }
+
+ leaf denied-notifications {
+ type yang:zero-based-counter32;
+ config false;
+ mandatory true;
+ description
+ "Number of times since the server last restarted that
+ a notification was dropped for a subscription because
+ access to the event type was denied.";
+ }
+
+ container groups {
+ description
+ "NETCONF access control groups.";
+
+ list group {
+ key name;
+
+ description
+ "One NACM group entry. This list will only contain
+ configured entries, not any entries learned from
+ any transport protocols.";
+
+ leaf name {
+ type group-name-type;
+ description
+ "Group name associated with this entry.";
+ }
+
+ leaf-list user-name {
+ type user-name-type;
+ description
+ "Each entry identifies the username of
+ a member of the group associated with
+ this entry.";
+ }
+ }
+ }
+
+ list rule-list {
+ key name;
+ ordered-by user;
+ description
+ "An ordered collection of access control rules.";
+
+ leaf name {
+ type string {
+ length "1..max";
+ }
+ description
+ "Arbitrary name assigned to the rule-list.";
+ }
+ leaf-list group {
+ type union {
+ type matchall-string-type;
+ type group-name-type;
+ }
+ description
+ "List of administrative groups that will be
+ assigned the associated access rights
+ defined by the 'rule' list.
+
+ The string '*' indicates that all groups apply to the
+ entry.";
+ }
+
+ list rule {
+ key name;
+ ordered-by user;
+ description
+ "One access control rule.
+
+ Rules are processed in user-defined order until a match is
+ found. A rule matches if 'module-name', 'rule-type', and
+ 'access-operations' match the request. If a rule
+ matches, the 'action' leaf determines whether or not
+ access is granted.";
+
+ leaf name {
+ type string {
+ length "1..max";
+ }
+ description
+ "Arbitrary name assigned to the rule.";
+ }
+
+ leaf module-name {
+ type union {
+ type matchall-string-type;
+ type string;
+ }
+ default "*";
+ description
+ "Name of the module associated with this rule.
+
+ This leaf matches if it has the value '*' or if the
+ object being accessed is defined in the module with the
+ specified module name.";
+ }
+ choice rule-type {
+ description
+ "This choice matches if all leafs present in the rule
+ match the request. If no leafs are present, the
+ choice matches all requests.";
+ case protocol-operation {
+ leaf rpc-name {
+ type union {
+ type matchall-string-type;
+ type string;
+ }
+ description
+ "This leaf matches if it has the value '*' or if
+ its value equals the requested protocol operation
+ name.";
+ }
+ }
+ case notification {
+ leaf notification-name {
+ type union {
+ type matchall-string-type;
+ type string;
+ }
+ description
+ "This leaf matches if it has the value '*' or if its
+ value equals the requested notification name.";
+ }
+ }
+ case data-node {
+ leaf path {
+ type node-instance-identifier;
+ mandatory true;
+ description
+ "Data node instance-identifier associated with the
+ data node, action, or notification controlled by
+ this rule.
+
+ Configuration data or state data
+ instance-identifiers start with a top-level
+ data node. A complete instance-identifier is
+ required for this type of path value.
+
+ The special value '/' refers to all possible
+ datastore contents.";
+ }
+ }
+ }
+
+ leaf access-operations {
+ type union {
+ type matchall-string-type;
+ type access-operations-type;
+ }
+ default "*";
+ description
+ "Access operations associated with this rule.
+
+ This leaf matches if it has the value '*' or if the
+ bit corresponding to the requested operation is set.";
+ }
+
+ leaf action {
+ type action-type;
+ mandatory true;
+ description
+ "The access control action associated with the
+ rule. If a rule has been determined to match a
+ particular request, then this object is used
+ to determine whether to permit or deny the
+ request.";
+ }
+
+ leaf comment {
+ type string;
+ description
+ "A textual description of the access rule.";
+ }
+ }
+ }
+ }
+}
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-yang-types@2013-07-15.yang b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-yang-types@2013-07-15.yang
new file mode 100644
index 0000000000000000000000000000000000000000..956562a7b342055127961732d8bde4be21c80d7d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/yang/ietf-yang-types@2013-07-15.yang
@@ -0,0 +1,475 @@
+ module ietf-yang-types {
+
+ namespace "urn:ietf:params:xml:ns:yang:ietf-yang-types";
+ prefix "yang";
+
+ organization
+ "IETF NETMOD (NETCONF Data Modeling Language) Working Group";
+
+ contact
+ "WG Web: <http://tools.ietf.org/wg/netmod/>
+ WG List: <mailto:netmod@ietf.org>
+
+ WG Chair: David Kessens
+ <mailto:david.kessens@nsn.com>
+
+ WG Chair: Juergen Schoenwaelder
+ <mailto:j.schoenwaelder@jacobs-university.de>
+
+ Editor: Juergen Schoenwaelder
+ <mailto:j.schoenwaelder@jacobs-university.de>";
+
+ description
+ "This module contains a collection of generally useful derived
+ YANG data types.
+
+ Copyright (c) 2013 IETF Trust and the persons identified as
+ authors of the code. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or
+ without modification, is permitted pursuant to, and subject
+ to the license terms contained in, the Simplified BSD License
+ set forth in Section 4.c of the IETF Trust's Legal Provisions
+ Relating to IETF Documents
+ (http://trustee.ietf.org/license-info).
+
+ This version of this YANG module is part of RFC 6991; see
+ the RFC itself for full legal notices.";
+
+ revision 2013-07-15 {
+ description
+ "This revision adds the following new data types:
+ - yang-identifier
+ - hex-string
+ - uuid
+ - dotted-quad";
+ reference
+ "RFC 6991: Common YANG Data Types";
+ }
+
+ revision 2010-09-24 {
+ description
+ "Initial revision.";
+ reference
+ "RFC 6021: Common YANG Data Types";
+ }
+
+ /*** collection of counter and gauge types ***/
+
+ typedef counter32 {
+ type uint32;
+ description
+ "The counter32 type represents a non-negative integer
+ that monotonically increases until it reaches a
+ maximum value of 2^32-1 (4294967295 decimal), when it
+ wraps around and starts increasing again from zero.
+
+ Counters have no defined 'initial' value, and thus, a
+ single value of a counter has (in general) no information
+ content. Discontinuities in the monotonically increasing
+ value normally occur at re-initialization of the
+ management system, and at other times as specified in the
+ description of a schema node using this type. If such
+ other times can occur, for example, the creation of
+ a schema node of type counter32 at times other than
+ re-initialization, then a corresponding schema node
+ should be defined, with an appropriate type, to indicate
+ the last discontinuity.
+
+ The counter32 type should not be used for configuration
+ schema nodes. A default statement SHOULD NOT be used in
+ combination with the type counter32.
+
+ In the value set and its semantics, this type is equivalent
+ to the Counter32 type of the SMIv2.";
+ reference
+ "RFC 2578: Structure of Management Information Version 2
+ (SMIv2)";
+ }
+
+ typedef zero-based-counter32 {
+ type yang:counter32;
+ default "0";
+ description
+ "The zero-based-counter32 type represents a counter32
+ that has the defined 'initial' value zero.
+
+ A schema node of this type will be set to zero (0) on creation
+ and will thereafter increase monotonically until it reaches
+ a maximum value of 2^32-1 (4294967295 decimal), when it
+ wraps around and starts increasing again from zero.
+
+ Provided that an application discovers a new schema node
+ of this type within the minimum time to wrap, it can use the
+ 'initial' value as a delta. It is important for a management
+ station to be aware of this minimum time and the actual time
+ between polls, and to discard data if the actual time is too
+ long or there is no defined minimum time.
+
+ In the value set and its semantics, this type is equivalent
+ to the ZeroBasedCounter32 textual convention of the SMIv2.";
+ reference
+ "RFC 4502: Remote Network Monitoring Management Information
+ Base Version 2";
+ }
+
+ typedef counter64 {
+ type uint64;
+ description
+ "The counter64 type represents a non-negative integer
+ that monotonically increases until it reaches a
+ maximum value of 2^64-1 (18446744073709551615 decimal),
+ when it wraps around and starts increasing again from zero.
+
+ Counters have no defined 'initial' value, and thus, a
+ single value of a counter has (in general) no information
+ content. Discontinuities in the monotonically increasing
+ value normally occur at re-initialization of the
+ management system, and at other times as specified in the
+ description of a schema node using this type. If such
+ other times can occur, for example, the creation of
+ a schema node of type counter64 at times other than
+ re-initialization, then a corresponding schema node
+ should be defined, with an appropriate type, to indicate
+ the last discontinuity.
+
+ The counter64 type should not be used for configuration
+ schema nodes. A default statement SHOULD NOT be used in
+ combination with the type counter64.
+
+ In the value set and its semantics, this type is equivalent
+ to the Counter64 type of the SMIv2.";
+ reference
+ "RFC 2578: Structure of Management Information Version 2
+ (SMIv2)";
+ }
+
+ typedef zero-based-counter64 {
+ type yang:counter64;
+ default "0";
+ description
+ "The zero-based-counter64 type represents a counter64 that
+ has the defined 'initial' value zero.
+
+ A schema node of this type will be set to zero (0) on creation
+ and will thereafter increase monotonically until it reaches
+ a maximum value of 2^64-1 (18446744073709551615 decimal),
+ when it wraps around and starts increasing again from zero.
+
+ Provided that an application discovers a new schema node
+ of this type within the minimum time to wrap, it can use the
+ 'initial' value as a delta. It is important for a management
+ station to be aware of this minimum time and the actual time
+ between polls, and to discard data if the actual time is too
+ long or there is no defined minimum time.
+
+ In the value set and its semantics, this type is equivalent
+ to the ZeroBasedCounter64 textual convention of the SMIv2.";
+ reference
+ "RFC 2856: Textual Conventions for Additional High Capacity
+ Data Types";
+ }
+
+ typedef gauge32 {
+ type uint32;
+ description
+ "The gauge32 type represents a non-negative integer, which
+ may increase or decrease, but shall never exceed a maximum
+ value, nor fall below a minimum value. The maximum value
+ cannot be greater than 2^32-1 (4294967295 decimal), and
+ the minimum value cannot be smaller than 0. The value of
+ a gauge32 has its maximum value whenever the information
+ being modeled is greater than or equal to its maximum
+ value, and has its minimum value whenever the information
+ being modeled is smaller than or equal to its minimum value.
+ If the information being modeled subsequently decreases
+ below (increases above) the maximum (minimum) value, the
+ gauge32 also decreases (increases).
+
+ In the value set and its semantics, this type is equivalent
+ to the Gauge32 type of the SMIv2.";
+ reference
+ "RFC 2578: Structure of Management Information Version 2
+ (SMIv2)";
+ }
+
+ typedef gauge64 {
+ type uint64;
+ description
+ "The gauge64 type represents a non-negative integer, which
+ may increase or decrease, but shall never exceed a maximum
+ value, nor fall below a minimum value. The maximum value
+ cannot be greater than 2^64-1 (18446744073709551615), and
+ the minimum value cannot be smaller than 0. The value of
+ a gauge64 has its maximum value whenever the information
+ being modeled is greater than or equal to its maximum
+ value, and has its minimum value whenever the information
+ being modeled is smaller than or equal to its minimum value.
+ If the information being modeled subsequently decreases
+ below (increases above) the maximum (minimum) value, the
+ gauge64 also decreases (increases).
+
+ In the value set and its semantics, this type is equivalent
+ to the CounterBasedGauge64 SMIv2 textual convention defined
+ in RFC 2856";
+ reference
+ "RFC 2856: Textual Conventions for Additional High Capacity
+ Data Types";
+ }
+
+ /*** collection of identifier-related types ***/
+
+ typedef object-identifier {
+ type string {
+ pattern '(([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))'
+ + '(\.(0|([1-9]\d*)))*';
+ }
+ description
+ "The object-identifier type represents administratively
+ assigned names in a registration-hierarchical-name tree.
+
+ Values of this type are denoted as a sequence of numerical
+ non-negative sub-identifier values. Each sub-identifier
+ value MUST NOT exceed 2^32-1 (4294967295). Sub-identifiers
+ are separated by single dots and without any intermediate
+ whitespace.
+
+ The ASN.1 standard restricts the value space of the first
+ sub-identifier to 0, 1, or 2. Furthermore, the value space
+ of the second sub-identifier is restricted to the range
+ 0 to 39 if the first sub-identifier is 0 or 1. Finally,
+ the ASN.1 standard requires that an object identifier
+ has always at least two sub-identifiers. The pattern
+ captures these restrictions.
+
+ Although the number of sub-identifiers is not limited,
+ module designers should realize that there may be
+ implementations that stick with the SMIv2 limit of 128
+ sub-identifiers.
+
+ This type is a superset of the SMIv2 OBJECT IDENTIFIER type
+ since it is not restricted to 128 sub-identifiers. Hence,
+ this type SHOULD NOT be used to represent the SMIv2 OBJECT
+ IDENTIFIER type; the object-identifier-128 type SHOULD be
+ used instead.";
+ reference
+ "ISO9834-1: Information technology -- Open Systems
+ Interconnection -- Procedures for the operation of OSI
+ Registration Authorities: General procedures and top
+ arcs of the ASN.1 Object Identifier tree";
+ }
+
+ typedef object-identifier-128 {
+ type object-identifier {
+ pattern '\d*(\.\d*){1,127}';
+ }
+ description
+ "This type represents object-identifiers restricted to 128
+ sub-identifiers.
+
+ In the value set and its semantics, this type is equivalent
+ to the OBJECT IDENTIFIER type of the SMIv2.";
+ reference
+ "RFC 2578: Structure of Management Information Version 2
+ (SMIv2)";
+ }
+
+ typedef yang-identifier {
+ type string {
+ length "1..max";
+ pattern '[a-zA-Z_][a-zA-Z0-9\-_.]*';
+ pattern '.|..|[^xX].*|.[^mM].*|..[^lL].*';
+ }
+ description
+ "A YANG identifier string as defined by the 'identifier'
+ rule in Section 12 of RFC 6020. An identifier must
+ start with an alphabetic character or an underscore
+ followed by an arbitrary sequence of alphabetic or
+ numeric characters, underscores, hyphens, or dots.
+
+ A YANG identifier MUST NOT start with any possible
+ combination of the lowercase or uppercase character
+ sequence 'xml'.";
+ reference
+ "RFC 6020: YANG - A Data Modeling Language for the Network
+ Configuration Protocol (NETCONF)";
+ }
+
+ /*** collection of types related to date and time***/
+
+ typedef date-and-time {
+ type string {
+ pattern '\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?'
+ + '(Z|[\+\-]\d{2}:\d{2})';
+ }
+ description
+ "The date-and-time type is a profile of the ISO 8601
+ standard for representation of dates and times using the
+ Gregorian calendar. The profile is defined by the
+ date-time production in Section 5.6 of RFC 3339.
+
+ The date-and-time type is compatible with the dateTime XML
+ schema type with the following notable exceptions:
+
+ (a) The date-and-time type does not allow negative years.
+
+ (b) The date-and-time time-offset -00:00 indicates an unknown
+ time zone (see RFC 3339) while -00:00 and +00:00 and Z
+ all represent the same time zone in dateTime.
+
+ (c) The canonical format (see below) of data-and-time values
+ differs from the canonical format used by the dateTime XML
+ schema type, which requires all times to be in UTC using
+ the time-offset 'Z'.
+
+ This type is not equivalent to the DateAndTime textual
+ convention of the SMIv2 since RFC 3339 uses a different
+ separator between full-date and full-time and provides
+ higher resolution of time-secfrac.
+
+ The canonical format for date-and-time values with a known time
+ zone uses a numeric time zone offset that is calculated using
+ the device's configured known offset to UTC time. A change of
+ the device's offset to UTC time will cause date-and-time values
+ to change accordingly. Such changes might happen periodically
+ in case a server follows automatically daylight saving time
+ (DST) time zone offset changes. The canonical format for
+ date-and-time values with an unknown time zone (usually
+ referring to the notion of local time) uses the time-offset
+ -00:00.";
+ reference
+ "RFC 3339: Date and Time on the Internet: Timestamps
+ RFC 2579: Textual Conventions for SMIv2
+ XSD-TYPES: XML Schema Part 2: Datatypes Second Edition";
+ }
+
+ typedef timeticks {
+ type uint32;
+ description
+ "The timeticks type represents a non-negative integer that
+ represents the time, modulo 2^32 (4294967296 decimal), in
+ hundredths of a second between two epochs. When a schema
+ node is defined that uses this type, the description of
+ the schema node identifies both of the reference epochs.
+
+ In the value set and its semantics, this type is equivalent
+ to the TimeTicks type of the SMIv2.";
+ reference
+ "RFC 2578: Structure of Management Information Version 2
+ (SMIv2)";
+ }
+
+ typedef timestamp {
+ type yang:timeticks;
+ description
+ "The timestamp type represents the value of an associated
+ timeticks schema node at which a specific occurrence
+ happened. The specific occurrence must be defined in the
+ description of any schema node defined using this type. When
+ the specific occurrence occurred prior to the last time the
+ associated timeticks attribute was zero, then the timestamp
+ value is zero. Note that this requires all timestamp values
+ to be reset to zero when the value of the associated timeticks
+ attribute reaches 497+ days and wraps around to zero.
+
+ The associated timeticks schema node must be specified
+ in the description of any schema node using this type.
+
+ In the value set and its semantics, this type is equivalent
+ to the TimeStamp textual convention of the SMIv2.";
+ reference
+ "RFC 2579: Textual Conventions for SMIv2";
+ }
+
+ /*** collection of generic address types ***/
+
+ typedef phys-address {
+ type string {
+ pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?';
+ }
+
+ description
+ "Represents media- or physical-level addresses represented
+ as a sequence octets, each octet represented by two hexadecimal
+ numbers. Octets are separated by colons. The canonical
+ representation uses lowercase characters.
+
+ In the value set and its semantics, this type is equivalent
+ to the PhysAddress textual convention of the SMIv2.";
+ reference
+ "RFC 2579: Textual Conventions for SMIv2";
+ }
+
+ typedef mac-address {
+ type string {
+ pattern '[0-9a-fA-F]{2}(:[0-9a-fA-F]{2}){5}';
+ }
+ description
+ "The mac-address type represents an IEEE 802 MAC address.
+ The canonical representation uses lowercase characters.
+
+ In the value set and its semantics, this type is equivalent
+ to the MacAddress textual convention of the SMIv2.";
+ reference
+ "IEEE 802: IEEE Standard for Local and Metropolitan Area
+ Networks: Overview and Architecture
+ RFC 2579: Textual Conventions for SMIv2";
+ }
+
+ /*** collection of XML-specific types ***/
+
+ typedef xpath1.0 {
+ type string;
+ description
+ "This type represents an XPATH 1.0 expression.
+
+ When a schema node is defined that uses this type, the
+ description of the schema node MUST specify the XPath
+ context in which the XPath expression is evaluated.";
+ reference
+ "XPATH: XML Path Language (XPath) Version 1.0";
+ }
+
+ /*** collection of string types ***/
+
+ typedef hex-string {
+ type string {
+ pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?';
+ }
+
+ description
+ "A hexadecimal string with octets represented as hex digits
+ separated by colons. The canonical representation uses
+ lowercase characters.";
+ }
+
+ typedef uuid {
+ type string {
+ pattern '[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-'
+ + '[0-9a-fA-F]{4}-[0-9a-fA-F]{12}';
+ }
+ description
+ "A Universally Unique IDentifier in the string representation
+ defined in RFC 4122. The canonical representation uses
+ lowercase characters.
+
+ The following is an example of a UUID in string representation:
+ f81d4fae-7dec-11d0-a765-00a0c91e6bf6
+ ";
+ reference
+ "RFC 4122: A Universally Unique IDentifier (UUID) URN
+ Namespace";
+ }
+
+ typedef dotted-quad {
+ type string {
+ pattern
+ '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}'
+ + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])';
+ }
+ description
+ "An unsigned 32-bit number expressed in the dotted-quad
+ notation, i.e., four octets written as decimal numbers
+ and separated with the '.' (full stop) character.";
+ }
+ }
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeLink.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeLink.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cc116a63506abcbd2d8e1377bbda453b1541bce
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeLink.py
@@ -0,0 +1,53 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from common.proto.context_pb2 import Link
+from .bindings.networks.network.link import link
+from .NameMapping import NameMappings
+from .NetworkTypeEnum import NetworkTypeEnum
+
+def compose_link(
+ ietf_link_obj : link, link_specs : Link, name_mappings : NameMappings, network_type : NetworkTypeEnum
+) -> None:
+ src_endpoint_id = link_specs.link_endpoint_ids[0]
+ ietf_link_obj.source.source_node = name_mappings.get_device_name(src_endpoint_id.device_id)
+ ietf_link_obj.source.source_tp = name_mappings.get_endpoint_name(src_endpoint_id)
+
+ dst_endpoint_id = link_specs.link_endpoint_ids[-1]
+ ietf_link_obj.destination.dest_node = name_mappings.get_device_name(dst_endpoint_id.device_id)
+ ietf_link_obj.destination.dest_tp = name_mappings.get_endpoint_name(dst_endpoint_id)
+
+ ietf_link_obj.te._set_oper_status('up')
+
+ te_link_attrs = ietf_link_obj.te.te_link_attributes
+ te_link_attrs.access_type = 'point-to-point'
+ te_link_attrs.admin_status = 'up'
+ te_link_attrs.name = link_specs.name
+
+ if network_type == NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY:
+ link_total_cap_kbps = link_specs.attributes.total_capacity_gbps * 1e6
+ link_used_cap_kbps = link_specs.attributes.used_capacity_gbps * 1e6
+ link_avail_cap_kbps = link_total_cap_kbps - link_used_cap_kbps
+
+ te_link_attrs.max_link_bandwidth.te_bandwidth.eth_bandwidth = link_total_cap_kbps
+ unresv_bw = te_link_attrs.unreserved_bandwidth.add(7)
+ unresv_bw.te_bandwidth.eth_bandwidth = link_avail_cap_kbps
+ elif network_type == NetworkTypeEnum.TE_OTN_TOPOLOGY:
+ te_link_attrs.te_delay_metric = 1
+ oduitem = te_link_attrs.max_link_bandwidth.te_bandwidth.otn.odulist.add('ietf-layer1-types:ODU0')
+ oduitem.ts_number = 80
+
+ unresv_bw = te_link_attrs.unreserved_bandwidth.add(7)
+ oduitem = unresv_bw.te_bandwidth.otn.odulist.add('ietf-layer1-types:ODU0')
+ oduitem.ts_number = 80
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeNetwork.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeNetwork.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ffc85e387ce4f4691cdc9757d6bd60068bef991
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeNetwork.py
@@ -0,0 +1,113 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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, re
+from common.DeviceTypes import DeviceTypeEnum
+from common.proto.context_pb2 import TopologyDetails
+from .bindings.networks.network import network
+from .ComposeLink import compose_link
+from .ComposeNode import compose_node
+from .NameMapping import NameMappings
+from .NetworkTypeEnum import NetworkTypeEnum, get_network_topology_type
+
+LOGGER = logging.getLogger(__name__)
+
+IGNORE_DEVICE_TYPES = {
+ DeviceTypeEnum.CLIENT.value,
+ DeviceTypeEnum.DATACENTER.value,
+ DeviceTypeEnum.EMULATED_CLIENT.value,
+ DeviceTypeEnum.EMULATED_DATACENTER.value,
+ DeviceTypeEnum.EMULATED_MICROWAVE_RADIO_SYSTEM.value,
+ DeviceTypeEnum.EMULATED_OPEN_LINE_SYSTEM.value,
+ DeviceTypeEnum.EMULATED_XR_CONSTELLATION.value,
+ DeviceTypeEnum.MICROWAVE_RADIO_SYSTEM.value,
+ DeviceTypeEnum.NETWORK.value,
+ DeviceTypeEnum.OPEN_LINE_SYSTEM.value,
+ DeviceTypeEnum.XR_CONSTELLATION.value,
+}
+
+IGNORE_DEVICE_NAMES = {
+ NetworkTypeEnum.TE_OTN_TOPOLOGY: {
+ '128.32.10.1', '128.32.33.5', '128.32.20.5', '128.32.20.1', '128.32.10.5', 'nce-t'
+ },
+ NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY: {
+
+ },
+}
+
+TE_TOPOLOGY_NAME = 'Huawei-Network'
+
+def compose_network(ietf_network_obj : network, te_topology_name : str, topology_details : TopologyDetails) -> None:
+ ietf_network_obj.te.name = TE_TOPOLOGY_NAME
+
+ #te_topology_name = topology_details.name
+ match = re.match(r'providerId\-([^\-]*)-clientId-([^\-]*)-topologyId-([^\-]*)', te_topology_name)
+ if match is not None:
+ provider_id, client_id, topology_id = match.groups()
+ ietf_network_obj.te_topology_identifier.provider_id = int(provider_id)
+ ietf_network_obj.te_topology_identifier.client_id = int(client_id)
+ ietf_network_obj.te_topology_identifier.topology_id = str(topology_id)
+ else:
+ ietf_network_obj.te_topology_identifier.provider_id = 10
+ ietf_network_obj.te_topology_identifier.client_id = 0
+ ietf_network_obj.te_topology_identifier.topology_id = '0'
+
+ ietf_network_obj.network_types.te_topology._set_present()
+ # TODO: resolve setting of otn_topology/eth_tran_topology network type; not working in bindings.
+ # See "../ManualFixes.py".
+ topology_id = ietf_network_obj.te_topology_identifier.topology_id
+ topology_id = {
+ '1': NetworkTypeEnum.TE_OTN_TOPOLOGY.value,
+ '2': NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY.value,
+ }.get(topology_id, topology_id)
+ network_type = get_network_topology_type(topology_id)
+ if network_type == NetworkTypeEnum.TE_OTN_TOPOLOGY:
+ #ietf_network_obj.network_types.te_topology.otn_topology._set_present()
+ pass
+ elif network_type == NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY:
+ #ietf_network_obj.network_types.te_topology.eth_tran_topology._set_present()
+ pass
+ else:
+ raise Exception('Unsupported TopologyId({:s})'.format(str(topology_id)))
+
+ name_mappings = NameMappings()
+
+ ignore_device_uuids = set()
+
+ for device in topology_details.devices:
+ device_uuid = device.device_id.device_uuid.uuid
+
+ device_type = device.device_type
+ if device_type in IGNORE_DEVICE_TYPES:
+ ignore_device_uuids.add(device_uuid)
+ continue
+
+ device_name = device.name
+ if device_name in IGNORE_DEVICE_NAMES.get(network_type, set()):
+ ignore_device_uuids.add(device_uuid)
+ continue
+
+ ietf_node_obj = ietf_network_obj.node.add(device_name)
+ compose_node(ietf_node_obj, device, name_mappings, network_type)
+
+ for link in topology_details.links:
+ link_device_uuids = {
+ endpoint_id.device_id.device_uuid.uuid
+ for endpoint_id in link.link_endpoint_ids
+ }
+ if len(ignore_device_uuids.intersection(link_device_uuids)) > 0:
+ continue
+ link_name = link.name
+ ietf_link_obj = ietf_network_obj.link.add(link_name)
+ compose_link(ietf_link_obj, link, name_mappings, network_type)
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeNode.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeNode.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4b29d41d7c27d588ce39b49c28746be47ad31f3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeNode.py
@@ -0,0 +1,107 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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 common.proto.context_pb2 import Device
+from .bindings.networks.network.node import node
+from .ComposeTermPoint import compose_term_point
+from .NameMapping import NameMappings
+from .NetworkTypeEnum import NetworkTypeEnum
+
+LOGGER = logging.getLogger(__name__)
+
+MAPPINGS_TE_NODE_NAME = {
+ '10.0.10.1' : 'OA',
+ '10.0.20.1' : 'P',
+ '10.0.30.1' : 'OE',
+ '10.0.40.1' : 'P',
+
+ '128.32.10.1': 'ONT1',
+ '128.32.20.1': 'ONT2',
+ '128.32.33.5': 'OLT',
+}
+
+IGNORE_ENDPOINT_NAMES = {'mgmt', 'eth1'}
+
+def compose_node(
+ ietf_node_obj : node, device : Device, name_mappings : NameMappings, network_type : NetworkTypeEnum
+) -> None:
+ device_name = device.name
+
+ name_mappings.store_device_name(device)
+
+ ietf_node_obj.te_node_id = device_name
+
+ ietf_node_obj.te._set_oper_status('up')
+ ietf_node_obj.te.te_node_attributes.admin_status = 'up'
+ ietf_node_obj.te.te_node_attributes.name = MAPPINGS_TE_NODE_NAME.get(device_name, device_name)
+
+ for endpoint in device.device_endpoints:
+ endpoint_name = endpoint.name
+ if endpoint_name in IGNORE_ENDPOINT_NAMES: continue
+ if network_type == NetworkTypeEnum.TE_OTN_TOPOLOGY and endpoint.endpoint_type != 'optical': continue
+
+ ietf_tp_obj = ietf_node_obj.termination_point.add(endpoint_name)
+ compose_term_point(ietf_tp_obj, device, endpoint, name_mappings, network_type)
+
+ if network_type == NetworkTypeEnum.TE_OTN_TOPOLOGY:
+ if device_name in {'10.0.30.1', '10.0.40.1'}:
+ ntaw = ietf_node_obj.te.tunnel_termination_point.add('NTAw')
+ ntaw.admin_status = 'up'
+ ntaw.encoding = 'ietf-te-types:lsp-encoding-oduk'
+ ntaw_llc = ntaw.local_link_connectivities.local_link_connectivity.add('500')
+ ntaw_llc.is_allowed = True
+ ntaw.name = '1-1-1-1-1'
+ ntaw._set_oper_status('up')
+ ntaw.protection_type = 'ietf-te-types:lsp-protection-unprotected'
+ ntaw.switching_capability = 'ietf-te-types:switching-otn'
+
+ ntax = ietf_node_obj.te.tunnel_termination_point.add('NTAx')
+ ntax.admin_status = 'up'
+ ntax.encoding = 'ietf-te-types:lsp-encoding-oduk'
+ ntax_llc = ntax.local_link_connectivities.local_link_connectivity.add('501')
+ ntax_llc.is_allowed = True
+ ntax.name = '1-1-1-1-1'
+ ntax._set_oper_status('up')
+ ntax.protection_type = 'ietf-te-types:lsp-protection-unprotected'
+ ntax.switching_capability = 'ietf-te-types:switching-otn'
+ elif device_name in {'10.0.10.1', '10.0.20.1'}:
+ ntax = ietf_node_obj.te.tunnel_termination_point.add('NTAx')
+ ntax.admin_status = 'up'
+ ntax.encoding = 'ietf-te-types:lsp-encoding-oduk'
+ ntax_llc = ntax.local_link_connectivities.local_link_connectivity.add('501')
+ ntax_llc.is_allowed = True
+ ntax.name = '1-1-1-1-1'
+ ntax._set_oper_status('up')
+ ntax.protection_type = 'ietf-te-types:lsp-protection-unprotected'
+ ntax.switching_capability = 'ietf-te-types:switching-otn'
+
+ ntaw = ietf_node_obj.te.tunnel_termination_point.add('NTAw')
+ ntaw.admin_status = 'up'
+ ntaw.encoding = 'ietf-te-types:lsp-encoding-oduk'
+ ntaw_llc = ntaw.local_link_connectivities.local_link_connectivity.add('500')
+ ntaw_llc.is_allowed = True
+ ntaw.name = '1-1-1-1-1'
+ ntaw._set_oper_status('up')
+ ntaw.protection_type = 'ietf-te-types:lsp-protection-unprotected'
+ ntaw.switching_capability = 'ietf-te-types:switching-otn'
+ elif network_type == NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY:
+ if device_name in {'128.32.33.5'}:
+ connectivity_matrices = ietf_node_obj.te.te_node_attributes.connectivity_matrices
+ lr0 = connectivity_matrices.label_restrictions.label_restriction.add(0)
+ lr0.label_start.te_label.vlanid = 21
+ lr0.label_end.te_label.vlanid = 21
+ lr1 = connectivity_matrices.label_restrictions.label_restriction.add(1)
+ lr1.label_start.te_label.vlanid = 31
+ lr1.label_end.te_label.vlanid = 31
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeTermPoint.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeTermPoint.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b65782a79c900cd3de8ec29fefd29036e2c014f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/ComposeTermPoint.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.
+
+import logging
+from common.proto.context_pb2 import Device, EndPoint
+from .bindings.networks.network.node.termination_point import termination_point
+from .NameMapping import NameMappings
+from .NetworkTypeEnum import NetworkTypeEnum
+
+MAPPINGS_TE_NAME = {
+ (NetworkTypeEnum.TE_OTN_TOPOLOGY, '10.0.10.1', '200'): '1-1-1-1-1',
+ (NetworkTypeEnum.TE_OTN_TOPOLOGY, '10.0.10.1', '500'): '1-1-1-1-1',
+ (NetworkTypeEnum.TE_OTN_TOPOLOGY, '10.0.10.1', '501'): '1-1-1-1-1',
+
+ (NetworkTypeEnum.TE_OTN_TOPOLOGY, '10.0.20.1', '500'): '1-1-1-1-1',
+ (NetworkTypeEnum.TE_OTN_TOPOLOGY, '10.0.20.1', '501'): '1-1-1-1-1',
+
+ (NetworkTypeEnum.TE_OTN_TOPOLOGY, '10.0.30.1', '200'): '1-1-1-1-1',
+ (NetworkTypeEnum.TE_OTN_TOPOLOGY, '10.0.30.1', '500'): '1-1-1-1-1',
+ (NetworkTypeEnum.TE_OTN_TOPOLOGY, '10.0.30.1', '501'): '1-1-1-1-1',
+
+ (NetworkTypeEnum.TE_OTN_TOPOLOGY, '10.0.40.1', '500'): '1-1-1-1-1',
+ (NetworkTypeEnum.TE_OTN_TOPOLOGY, '10.0.40.1', '501'): '1-1-1-1-1',
+
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.10.1', '200'): 'endpoint:111',
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.10.1', '500'): 'endpoint:111',
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.10.1', '501'): 'endpoint:111',
+
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.20.1', '500'): 'endpoint:111',
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.20.1', '501'): 'endpoint:111',
+
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.30.1', '200'): 'endpoint:111',
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.30.1', '500'): 'endpoint:111',
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.30.1', '501'): 'endpoint:111',
+
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.40.1', '500'): 'endpoint:111',
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.40.1', '501'): 'endpoint:111',
+
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '128.32.33.5', '500') : 'endpoint:111',
+}
+
+MAPPINGS_TE_TP_ID = {
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.10.1', '200'): '128.32.33.254',
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '10.0.30.1', '200'): '172.10.33.254',
+
+ (NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY, '128.32.33.5', '500') : '128.32.33.2',
+}
+
+LOGGER = logging.getLogger(__name__)
+
+def compose_term_point(
+ ietf_tp_obj : termination_point, device : Device, endpoint : EndPoint, name_mappings : NameMappings,
+ network_type : NetworkTypeEnum
+) -> None:
+ name_mappings.store_endpoint_name(device, endpoint)
+
+ device_name = device.name
+ endpoint_name = endpoint.name
+
+ ietf_tp_obj.te_tp_id = MAPPINGS_TE_TP_ID.get((network_type, device_name, endpoint_name), endpoint_name)
+
+ if (network_type, device_name, endpoint_name) in MAPPINGS_TE_NAME:
+ ietf_tp_obj.te._set_oper_status('up')
+ ietf_tp_obj.te.admin_status = 'up'
+ ietf_tp_obj.te.name = MAPPINGS_TE_NAME.get((network_type, device_name, endpoint_name), endpoint_name)
+
+ if network_type == NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY:
+ if (network_type, device_name, endpoint_name) in MAPPINGS_TE_NAME:
+ ietf_if_sw_cap = ietf_tp_obj.te.interface_switching_capability.add(
+ 'ietf-te-types:switching-l2sc ietf-te-types:lsp-encoding-ethernet'
+ )
+ ietf_max_lsp_bw = ietf_if_sw_cap.max_lsp_bandwidth.add('7')
+ ietf_max_lsp_bw.te_bandwidth.eth_bandwidth = 10_000_000 # Kbps
+
+ #ietf_tp_obj.eth_svc.client_facing = True
+
+ ietf_tp_obj.eth_svc.supported_classification.port_classification = True
+ outer_tag = ietf_tp_obj.eth_svc.supported_classification.vlan_classification.outer_tag
+ outer_tag.supported_tag_types.append('ietf-eth-tran-types:classify-c-vlan')
+ outer_tag.supported_tag_types.append('ietf-eth-tran-types:classify-s-vlan')
+ outer_tag.vlan_bundling = False
+ outer_tag.vlan_range = '1-4094'
+
+ elif network_type == NetworkTypeEnum.TE_OTN_TOPOLOGY:
+ #ietf_tp_obj.te.client_svc.client_facing = False
+
+ ietf_if_sw_cap = ietf_tp_obj.te.interface_switching_capability.add(
+ 'ietf-te-types:switching-otn ietf-te-types:lsp-encoding-oduk'
+ )
+ ietf_max_lsp_bw = ietf_if_sw_cap.max_lsp_bandwidth.add('7')
+ ietf_max_lsp_bw.te_bandwidth.otn.odu_type = 'ietf-layer1-types:ODU4'
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/ManualFixes.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/ManualFixes.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec95ee77fc3cfefc54365977ed17f2218cbc2ec4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/ManualFixes.py
@@ -0,0 +1,73 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Dict
+
+from .NetworkTypeEnum import NetworkTypeEnum
+
+def manual_fixes(json_response : Dict) -> None:
+ # TODO: workaround to set network types manually. Currently does not work; refine bindings.
+ # Seems limitation of pyangbind using multiple augmentations and nested empty containers.
+ for json_network in json_response['ietf-network:networks']['network']:
+ net_te_topo_id = json_network.get('ietf-te-topology:te-topology-identifier', {}).get('topology-id')
+ if net_te_topo_id is None: continue
+ net_te_topo_type = json_network['network-types']['ietf-te-topology:te-topology']
+ if net_te_topo_id == '1':
+ network_type = NetworkTypeEnum.TE_OTN_TOPOLOGY
+ net_te_topo_type['ietf-otn-topology:otn-topology'] = {}
+ elif net_te_topo_id == '2':
+ network_type = NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY
+ net_te_topo_type['ietf-eth-te-topology:eth-tran-topology'] = {}
+ else:
+ network_type = None
+
+ for json_node in json_network.get('node', []):
+ for json_tp in json_node.get('ietf-network-topology:termination-point', []):
+ json_tp_te = json_tp.get('ietf-te-topology:te', {})
+
+ if network_type == NetworkTypeEnum.TE_OTN_TOPOLOGY:
+ json_tp_te_cs = json_tp_te.setdefault('ietf-otn-topology:client-svc', {})
+ json_tp_te_cs['client-facing'] = False
+ elif network_type == NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY:
+ if 'ietf-eth-te-topology:eth-svc' in json_tp:
+ client_facing = json_tp['tp-id'] in {'200', '201'}
+ json_tp['ietf-eth-te-topology:eth-svc']['client-facing'] = client_facing
+
+ # Fix value type of bandwidth
+ for json_if_sw_cap in json_tp_te.get('interface-switching-capability', []):
+ for json_max_lsp_bandwidth in json_if_sw_cap.get('max-lsp-bandwidth', []):
+ json_te_bw = json_max_lsp_bandwidth.get('te-bandwidth', {})
+ if network_type == NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY:
+ if 'ietf-eth-te-topology:eth-bandwidth' in json_te_bw:
+ eth_bw = json_te_bw['ietf-eth-te-topology:eth-bandwidth']
+ if isinstance(eth_bw, str):
+ json_te_bw['ietf-eth-te-topology:eth-bandwidth'] = int(eth_bw)
+
+ for json_link in json_network.get('ietf-network-topology:link', []):
+ json_link_te_attributes = json_link.get('ietf-te-topology:te', {}).get('te-link-attributes', {})
+
+ # Fix value type of bandwidth
+ json_te_bw = json_link_te_attributes.get('max-link-bandwidth', {}).get('te-bandwidth', {})
+ if network_type == NetworkTypeEnum.TE_ETH_TRAN_TOPOLOGY:
+ if 'ietf-eth-te-topology:eth-bandwidth' in json_te_bw:
+ eth_bw = json_te_bw['ietf-eth-te-topology:eth-bandwidth']
+ if isinstance(eth_bw, str):
+ json_te_bw['ietf-eth-te-topology:eth-bandwidth'] = int(eth_bw)
+
+ for json_unresv_bandwidth in json_link_te_attributes.get('unreserved-bandwidth', []):
+ json_te_bw = json_unresv_bandwidth.get('te-bandwidth', {})
+ if 'ietf-eth-te-topology:eth-bandwidth' in json_te_bw:
+ eth_bw = json_te_bw['ietf-eth-te-topology:eth-bandwidth']
+ if isinstance(eth_bw, str):
+ json_te_bw['ietf-eth-te-topology:eth-bandwidth'] = int(eth_bw)
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/NameMapping.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/NameMapping.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5f9ca5f8748f4ba7e835430d057cc000278fbd1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/NameMapping.py
@@ -0,0 +1,46 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Dict, Tuple
+from common.proto.context_pb2 import Device, DeviceId, EndPoint, EndPointId
+
+class NameMappings:
+ def __init__(self) -> None:
+ self._device_uuid_to_name : Dict[str, str] = dict()
+ self._endpoint_uuid_to_name : Dict[Tuple[str, str], str] = dict()
+
+ def store_device_name(self, device : Device) -> None:
+ device_uuid = device.device_id.device_uuid.uuid
+ device_name = device.name
+ self._device_uuid_to_name[device_uuid] = device_name
+ self._device_uuid_to_name[device_name] = device_name
+
+ def store_endpoint_name(self, device : Device, endpoint : EndPoint) -> None:
+ device_uuid = device.device_id.device_uuid.uuid
+ device_name = device.name
+ endpoint_uuid = endpoint.endpoint_id.endpoint_uuid.uuid
+ endpoint_name = endpoint.name
+ self._endpoint_uuid_to_name[(device_uuid, endpoint_uuid)] = endpoint_name
+ self._endpoint_uuid_to_name[(device_name, endpoint_uuid)] = endpoint_name
+ self._endpoint_uuid_to_name[(device_uuid, endpoint_name)] = endpoint_name
+ self._endpoint_uuid_to_name[(device_name, endpoint_name)] = endpoint_name
+
+ def get_device_name(self, device_id : DeviceId) -> str:
+ device_uuid = device_id.device_uuid.uuid
+ return self._device_uuid_to_name.get(device_uuid, device_uuid)
+
+ def get_endpoint_name(self, endpoint_id : EndPointId) -> str:
+ device_uuid = endpoint_id.device_id.device_uuid.uuid
+ endpoint_uuid = endpoint_id.endpoint_uuid.uuid
+ return self._endpoint_uuid_to_name.get((device_uuid, endpoint_uuid), endpoint_uuid)
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/NetworkTypeEnum.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/NetworkTypeEnum.py
new file mode 100644
index 0000000000000000000000000000000000000000..62cc74219c1e0d47231db76e73f1b960f26f4abe
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/NetworkTypeEnum.py
@@ -0,0 +1,23 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from enum import Enum
+from typing import Optional
+
+class NetworkTypeEnum(Enum):
+ TE_OTN_TOPOLOGY = 'otn'
+ TE_ETH_TRAN_TOPOLOGY = 'eth-tran'
+
+def get_network_topology_type(topology_id : str) -> Optional[NetworkTypeEnum]:
+ return NetworkTypeEnum._value2member_map_.get(topology_id)
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/Networks.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/Networks.py
new file mode 100644
index 0000000000000000000000000000000000000000..47a126ec886b2b4102aab470bcca27bc52d35ab7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/Networks.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.
+
+import json, logging
+import pyangbind.lib.pybindJSON as pybindJSON
+from flask import request
+from flask.json import jsonify
+from flask_restful import Resource
+from common.Constants import DEFAULT_CONTEXT_NAME, DEFAULT_TOPOLOGY_NAME
+from common.tools.context_queries.Topology import get_topology_details
+from context.client.ContextClient import ContextClient
+from nbi.service.rest_server.nbi_plugins.tools.Authentication import HTTP_AUTH
+from nbi.service.rest_server.nbi_plugins.tools.HttpStatusCodes import HTTP_OK, HTTP_SERVERERROR
+from .bindings import ietf_network
+from .ComposeNetwork import compose_network
+from .ManualFixes import manual_fixes
+
+LOGGER = logging.getLogger(__name__)
+
+TE_TOPOLOGY_NAMES = [
+ 'providerId-10-clientId-0-topologyId-1',
+ 'providerId-10-clientId-0-topologyId-2'
+]
+
+class Networks(Resource):
+ @HTTP_AUTH.login_required
+ def get(self):
+ LOGGER.info('Request: {:s}'.format(str(request)))
+ topology_id = ''
+ try:
+ context_client = ContextClient()
+ #target = get_slice_by_uuid(context_client, vpn_id, rw_copy=True)
+ #if target is None:
+ # raise Exception('VPN({:s}) not found in database'.format(str(vpn_id)))
+
+ ietf_nets = ietf_network()
+
+ topology_details = get_topology_details(
+ context_client, DEFAULT_TOPOLOGY_NAME, context_uuid=DEFAULT_CONTEXT_NAME, #rw_copy=True
+ )
+ if topology_details is None:
+ MSG = 'Topology({:s}/{:s}) not found'
+ raise Exception(MSG.format(DEFAULT_CONTEXT_NAME, DEFAULT_TOPOLOGY_NAME))
+
+ for te_topology_name in TE_TOPOLOGY_NAMES:
+ ietf_net = ietf_nets.networks.network.add(te_topology_name)
+ compose_network(ietf_net, te_topology_name, topology_details)
+
+ # TODO: improve these workarounds to enhance performance
+ json_response = json.loads(pybindJSON.dumps(ietf_nets, mode='ietf'))
+
+ # Workaround; pyangbind does not allow to set otn_topology / eth-tran-topology
+ manual_fixes(json_response)
+
+ response = jsonify(json_response)
+ response.status_code = HTTP_OK
+ except Exception as e: # pylint: disable=broad-except
+ LOGGER.exception('Something went wrong Retrieving Topology({:s})'.format(str(topology_id)))
+ response = jsonify({'error': str(e)})
+ response.status_code = HTTP_SERVERERROR
+ return response
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/README.md b/src/nbi/service/rest_server/nbi_plugins/ietf_network/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8d808a45b54efa3126c408bda97b51659b511cee
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/README.md
@@ -0,0 +1,14 @@
+# IETF Network
+
+This NBI plugin implements a basic skeleton for the IETF Network data model.
+
+## DISCLAIMER
+__USE WITH CARE! This plugin is NOT production ready, it contains many hardcodings based on ongoing tests.__
+
+## IETF RFCs/drafts:
+- RFC 8795 - YANG Data Model for Traffic Engineering (TE) Topologies (https://datatracker.ietf.org/doc/html/rfc8795)
+- RFC 8776 - Common YANG Data Types for Traffic Engineering (https://datatracker.ietf.org/doc/html/rfc8776)
+- RFC 8345 - A YANG Data Model for Network Topologies (https://datatracker.ietf.org/doc/html/rfc8345)
+- RFC 6991 - Common YANG Data Types (https://datatracker.ietf.org/doc/html/rfc6991)
+- RFC draft-ietf-ccamp-eth-client-te-topo-yang-05 - A YANG Data Model for Ethernet TE Topology (https://datatracker.ietf.org/doc/draft-ietf-ccamp-eth-client-te-topo-yang/)
+- RFC draft-ietf-ccamp-client-signal-yang-10 - A YANG Data Model for Transport Network Client Signals (https://datatracker.ietf.org/doc/draft-ietf-ccamp-client-signal-yang/)
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e637c6719b927b7b53550ae68618859cf5976cc9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/__init__.py
@@ -0,0 +1,44 @@
+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# RFC 8795 - YANG Data Model for Traffic Engineering (TE) Topologies
+# Ref: https://datatracker.ietf.org/doc/html/rfc8795
+
+# RFC 8776 - Common YANG Data Types for Traffic Engineering
+# Ref: https://datatracker.ietf.org/doc/html/rfc8776
+
+# RFC 8345 - A YANG Data Model for Network Topologies
+# Ref: https://datatracker.ietf.org/doc/html/rfc8345
+
+# RFC 6991 - Common YANG Data Types
+# Ref: https://datatracker.ietf.org/doc/html/rfc6991
+
+# RFC draft-ietf-ccamp-eth-client-te-topo-yang-05 - A YANG Data Model for Ethernet TE Topology
+# Ref: https://datatracker.ietf.org/doc/draft-ietf-ccamp-eth-client-te-topo-yang/
+
+# RFC draft-ietf-ccamp-client-signal-yang-10 - A YANG Data Model for Transport Network Client Signals
+# Ref: https://datatracker.ietf.org/doc/draft-ietf-ccamp-client-signal-yang/
+
+from flask_restful import Resource
+from nbi.service.rest_server.RestServer import RestServer
+from .Networks import Networks
+
+URL_PREFIX = '/restconf/data/ietf-network:networks'
+
+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_network(rest_server : RestServer):
+ _add_resource(rest_server, Networks, '/')
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/_docs/test_commands.txt b/src/nbi/service/rest_server/nbi_plugins/ietf_network/_docs/test_commands.txt
new file mode 100644
index 0000000000000000000000000000000000000000..78b2dd24686b6dbecae67cf09bef38f38b97d401
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/_docs/test_commands.txt
@@ -0,0 +1,26 @@
+cd ~/tfs-ctrl/src/nbi/service/rest_server/nbi_plugins/ietf_network
+
+python
+
+from bindings import ietf_network
+import pyangbind.lib.pybindJSON as pybindJSON
+
+ietf_nets_obj = ietf_network()
+ietf_net_obj = ietf_nets_obj.networks.network.add('my-topo')
+
+ietf_node_obj = ietf_net_obj.node.add('my-node')
+ietf_tp_obj = ietf_node_obj.termination_point.add('my-tp')
+
+ietf_link_obj = ietf_net_obj.link.add('my-link')
+
+ietf_link_obj.te._set_oper_status('up')
+print(pybindJSON.dumps(ietf_nets_obj, mode='ietf'))
+
+ietf_link_obj.te.te_link_attributes.admin_status = 'down'
+print(pybindJSON.dumps(ietf_nets_obj, mode='ietf'))
+
+
+ietf_link_obj.te.te_link_attributes.max_link_bandwidth.te_bandwidth.eth_bandwidth = 10_000_000 # Kbps
+unresv_bw = ietf_link_obj.te.te_link_attributes.unreserved_bandwidth.add(7)
+unresv_bw.te_bandwidth.eth_bandwidth = 10_000_000 # Kbps
+print(pybindJSON.dumps(ietf_link_obj, mode='ietf'))
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6df50e1a6aff3868ecb25323b33f4b48bf92901f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ietf_network_topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network-topology - based on the path /ietf-network-topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This module defines a common base model for a network topology,
+augmenting the base network data model with links to connect
+nodes, as well as termination points to terminate links
+on nodes.
+
+Copyright (c) 2018 IETF Trust and the persons identified as
+authors of the code. All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, is permitted pursuant to, and subject
+to the license terms contained in, the Simplified BSD License
+set forth in Section 4.c of the IETF Trust's Legal Provisions
+Relating to IETF Documents
+(https://trustee.ietf.org/license-info).
+
+This version of this YANG module is part of RFC 8345;
+see the RFC itself for full legal notices.
+ """
+ _pyangbind_elements = {}
+
+
+
+from . import networks
+class ietf_network(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /ietf-network. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This module defines a common base data model for a collection
+of nodes in a network. Node definitions are further used
+in network topologies and inventories.
+
+Copyright (c) 2018 IETF Trust and the persons identified as
+authors of the code. All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, is permitted pursuant to, and subject
+to the license terms contained in, the Simplified BSD License
+set forth in Section 4.c of the IETF Trust's Legal Provisions
+Relating to IETF Documents
+(https://trustee.ietf.org/license-info).
+
+This version of this YANG module is part of RFC 8345;
+see the RFC itself for full legal notices.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__networks',)
+
+ _yang_name = 'ietf-network'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__networks = YANGDynClass(base=networks.networks, is_container='container', yang_name="networks", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return []
+
+ def _get_networks(self):
+ """
+ Getter method for networks, mapped from YANG variable /networks (container)
+
+ YANG Description: Serves as a top-level container for a list of networks.
+ """
+ return self.__networks
+
+ def _set_networks(self, v, load=False):
+ """
+ Setter method for networks, mapped from YANG variable /networks (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_networks is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_networks() directly.
+
+ YANG Description: Serves as a top-level container for a list of networks.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=networks.networks, is_container='container', yang_name="networks", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """networks must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=networks.networks, is_container='container', yang_name="networks", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='container', is_config=True)""",
+ })
+
+ self.__networks = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_networks(self):
+ self.__networks = YANGDynClass(base=networks.networks, is_container='container', yang_name="networks", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='container', is_config=True)
+
+ networks = __builtin__.property(_get_networks, _set_networks)
+
+
+ _pyangbind_elements = OrderedDict([('networks', networks), ])
+
+
+class ietf_te_topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-te-topology - based on the path /ietf-te-topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This YANG module defines a TE topology model for representing,
+retrieving, and manipulating technology-agnostic TE topologies.
+
+Copyright (c) 2020 IETF Trust and the persons identified as
+authors of the code. All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, is permitted pursuant to, and subject to
+the license terms contained in, the Simplified BSD License set
+forth in Section 4.c of the IETF Trust's Legal Provisions
+Relating to IETF Documents
+(https://trustee.ietf.org/license-info).
+
+This version of this YANG module is part of RFC 8795; see the
+RFC itself for full legal notices.
+ """
+ _pyangbind_elements = {}
+
+
+
+class ietf_otn_topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-otn-topology - based on the path /ietf-otn-topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This module defines a protocol independent Layer 1/ODU topology
+data model. The model fully conforms
+to the Network Management Datastore Architecture (NMDA).
+
+Copyright (c) 2023 IETF Trust and the persons identified
+as authors of the code. All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, is permitted pursuant to, and subject
+to the license terms contained in, the Revised BSD License
+set forth in Section 4.c of the IETF Trust's Legal Provisions
+Relating to IETF Documents
+(https://trustee.ietf.org/license-info).
+
+This version of this YANG module is part of RFC XXXX; see
+the RFC itself for full legal notices.
+
+The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL
+NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED',
+'MAY', and 'OPTIONAL' in this document are to be interpreted as
+described in BCP 14 (RFC 2119) (RFC 8174) when, and only when,
+they appear in all capitals, as shown here.
+ """
+ _pyangbind_elements = {}
+
+
+
+class ietf_eth_te_topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-eth-te-topology - based on the path /ietf-eth-te-topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This module defines a YANG data model for describing
+layer-2 Ethernet transport topologies. The model fully
+conforms to the Network Management Datastore
+Architecture (NMDA).
+
+Copyright (c) 2023 IETF Trust and the persons identified
+as authors of the code. All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, is permitted pursuant to, and subject
+to the license terms contained in, the Revised BSD License
+set forth in Section 4.c of the IETF Trust's Legal Provisions
+Relating to IETF Documents
+(https://trustee.ietf.org/license-info).
+
+This version of this YANG module is part of RFC XXXX; see
+the RFC itself for full legal notices.
+
+The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL
+NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED',
+'MAY', and 'OPTIONAL' in this document are to be interpreted as
+described in BCP 14 (RFC 2119) (RFC 8174) when, and only when,
+they appear in all capitals, as shown here.
+ """
+ _pyangbind_elements = {}
+
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c52044ebfd602a81ac0b8be69eed96d15fd9261
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/__init__.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import network
+from . import te
+class networks(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Serves as a top-level container for a list of networks.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network','__te',)
+
+ _yang_name = 'networks'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network = YANGDynClass(base=YANGListType("network_id",network.network, yang_name="network", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-id', extensions=None), is_container='list', yang_name="network", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+ self.__te = YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks']
+
+ def _get_network(self):
+ """
+ Getter method for network, mapped from YANG variable /networks/network (list)
+
+ YANG Description: Describes a network.
+A network typically contains an inventory of nodes,
+topological information (augmented through the
+network-topology data model), and layering information.
+ """
+ return self.__network
+
+ def _set_network(self, v, load=False):
+ """
+ Setter method for network, mapped from YANG variable /networks/network (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network() directly.
+
+ YANG Description: Describes a network.
+A network typically contains an inventory of nodes,
+topological information (augmented through the
+network-topology data model), and layering information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("network_id",network.network, yang_name="network", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-id', extensions=None), is_container='list', yang_name="network", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("network_id",network.network, yang_name="network", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-id', extensions=None), is_container='list', yang_name="network", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)""",
+ })
+
+ self.__network = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network(self):
+ self.__network = YANGDynClass(base=YANGListType("network_id",network.network, yang_name="network", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-id', extensions=None), is_container='list', yang_name="network", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+
+
+ def _get_te(self):
+ """
+ Getter method for te, mapped from YANG variable /networks/te (container)
+
+ YANG Description: Indicates TE support.
+ """
+ return self.__te
+
+ def _set_te(self, v, load=False):
+ """
+ Setter method for te, mapped from YANG variable /networks/te (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te() directly.
+
+ YANG Description: Indicates TE support.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te(self):
+ self.__te = YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ network = __builtin__.property(_get_network, _set_network)
+ te = __builtin__.property(_get_te, _set_te)
+
+
+ _pyangbind_elements = OrderedDict([('network', network), ('te', te), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..302af85c96e588326bdbef9c9c796da1c6998c16
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/__init__.py
@@ -0,0 +1,385 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import network_types
+from . import supporting_network
+from . import node
+from . import link
+from . import te_topology_identifier
+from . import te
+class network(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Describes a network.
+A network typically contains an inventory of nodes,
+topological information (augmented through the
+network-topology data model), and layering information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_id','__network_types','__supporting_network','__node','__link','__te_topology_identifier','__te',)
+
+ _yang_name = 'network'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_id = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='network-id', is_config=True)
+ self.__network_types = YANGDynClass(base=network_types.network_types, is_container='container', yang_name="network-types", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='container', is_config=True)
+ self.__supporting_network = YANGDynClass(base=YANGListType("network_ref",supporting_network.supporting_network, yang_name="supporting-network", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref', extensions=None), is_container='list', yang_name="supporting-network", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+ self.__node = YANGDynClass(base=YANGListType("node_id",node.node, yang_name="node", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='node-id', extensions=None), is_container='list', yang_name="node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+ self.__link = YANGDynClass(base=YANGListType("link_id",link.link, yang_name="link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='link-id', extensions=None), is_container='list', yang_name="link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)
+ self.__te_topology_identifier = YANGDynClass(base=te_topology_identifier.te_topology_identifier, is_container='container', yang_name="te-topology-identifier", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__te = YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network']
+
+ def _get_network_id(self):
+ """
+ Getter method for network_id, mapped from YANG variable /networks/network/network_id (network-id)
+
+ YANG Description: Identifies a network.
+ """
+ return self.__network_id
+
+ def _set_network_id(self, v, load=False):
+ """
+ Setter method for network_id, mapped from YANG variable /networks/network/network_id (network-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_id() directly.
+
+ YANG Description: Identifies a network.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='network-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_id must be of a type compatible with network-id""",
+ 'defined-type': "ietf-network:network-id",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='network-id', is_config=True)""",
+ })
+
+ self.__network_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_id(self):
+ self.__network_id = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='network-id', is_config=True)
+
+
+ def _get_network_types(self):
+ """
+ Getter method for network_types, mapped from YANG variable /networks/network/network_types (container)
+
+ YANG Description: Serves as an augmentation target.
+The network type is indicated through corresponding
+presence containers augmented into this container.
+ """
+ return self.__network_types
+
+ def _set_network_types(self, v, load=False):
+ """
+ Setter method for network_types, mapped from YANG variable /networks/network/network_types (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_types is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_types() directly.
+
+ YANG Description: Serves as an augmentation target.
+The network type is indicated through corresponding
+presence containers augmented into this container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=network_types.network_types, is_container='container', yang_name="network-types", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_types must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=network_types.network_types, is_container='container', yang_name="network-types", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='container', is_config=True)""",
+ })
+
+ self.__network_types = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_types(self):
+ self.__network_types = YANGDynClass(base=network_types.network_types, is_container='container', yang_name="network-types", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='container', is_config=True)
+
+
+ def _get_supporting_network(self):
+ """
+ Getter method for supporting_network, mapped from YANG variable /networks/network/supporting_network (list)
+
+ YANG Description: An underlay network, used to represent layered network
+topologies.
+ """
+ return self.__supporting_network
+
+ def _set_supporting_network(self, v, load=False):
+ """
+ Setter method for supporting_network, mapped from YANG variable /networks/network/supporting_network (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_supporting_network is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_supporting_network() directly.
+
+ YANG Description: An underlay network, used to represent layered network
+topologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("network_ref",supporting_network.supporting_network, yang_name="supporting-network", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref', extensions=None), is_container='list', yang_name="supporting-network", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """supporting_network must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("network_ref",supporting_network.supporting_network, yang_name="supporting-network", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref', extensions=None), is_container='list', yang_name="supporting-network", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)""",
+ })
+
+ self.__supporting_network = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_supporting_network(self):
+ self.__supporting_network = YANGDynClass(base=YANGListType("network_ref",supporting_network.supporting_network, yang_name="supporting-network", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref', extensions=None), is_container='list', yang_name="supporting-network", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+
+
+ def _get_node(self):
+ """
+ Getter method for node, mapped from YANG variable /networks/network/node (list)
+
+ YANG Description: The inventory of nodes of this network.
+ """
+ return self.__node
+
+ def _set_node(self, v, load=False):
+ """
+ Setter method for node, mapped from YANG variable /networks/network/node (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node() directly.
+
+ YANG Description: The inventory of nodes of this network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("node_id",node.node, yang_name="node", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='node-id', extensions=None), is_container='list', yang_name="node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("node_id",node.node, yang_name="node", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='node-id', extensions=None), is_container='list', yang_name="node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)""",
+ })
+
+ self.__node = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node(self):
+ self.__node = YANGDynClass(base=YANGListType("node_id",node.node, yang_name="node", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='node-id', extensions=None), is_container='list', yang_name="node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+
+
+ def _get_link(self):
+ """
+ Getter method for link, mapped from YANG variable /networks/network/link (list)
+
+ YANG Description: A network link connects a local (source) node and
+a remote (destination) node via a set of the respective
+node's termination points. It is possible to have several
+links between the same source and destination nodes.
+Likewise, a link could potentially be re-homed between
+termination points. Therefore, in order to ensure that we
+would always know to distinguish between links, every link
+is identified by a dedicated link identifier. Note that a
+link models a point-to-point link, not a multipoint link.
+ """
+ return self.__link
+
+ def _set_link(self, v, load=False):
+ """
+ Setter method for link, mapped from YANG variable /networks/network/link (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link() directly.
+
+ YANG Description: A network link connects a local (source) node and
+a remote (destination) node via a set of the respective
+node's termination points. It is possible to have several
+links between the same source and destination nodes.
+Likewise, a link could potentially be re-homed between
+termination points. Therefore, in order to ensure that we
+would always know to distinguish between links, every link
+is identified by a dedicated link identifier. Note that a
+link models a point-to-point link, not a multipoint link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("link_id",link.link, yang_name="link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='link-id', extensions=None), is_container='list', yang_name="link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("link_id",link.link, yang_name="link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='link-id', extensions=None), is_container='list', yang_name="link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__link = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link(self):
+ self.__link = YANGDynClass(base=YANGListType("link_id",link.link, yang_name="link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='link-id', extensions=None), is_container='list', yang_name="link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)
+
+
+ def _get_te_topology_identifier(self):
+ """
+ Getter method for te_topology_identifier, mapped from YANG variable /networks/network/te_topology_identifier (container)
+
+ YANG Description: TE topology identifier container.
+ """
+ return self.__te_topology_identifier
+
+ def _set_te_topology_identifier(self, v, load=False):
+ """
+ Setter method for te_topology_identifier, mapped from YANG variable /networks/network/te_topology_identifier (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_topology_identifier is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_topology_identifier() directly.
+
+ YANG Description: TE topology identifier container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_topology_identifier.te_topology_identifier, is_container='container', yang_name="te-topology-identifier", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_topology_identifier must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_topology_identifier.te_topology_identifier, is_container='container', yang_name="te-topology-identifier", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_topology_identifier = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_topology_identifier(self):
+ self.__te_topology_identifier = YANGDynClass(base=te_topology_identifier.te_topology_identifier, is_container='container', yang_name="te-topology-identifier", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_te(self):
+ """
+ Getter method for te, mapped from YANG variable /networks/network/te (container)
+
+ YANG Description: Indicates TE support.
+ """
+ return self.__te
+
+ def _set_te(self, v, load=False):
+ """
+ Setter method for te, mapped from YANG variable /networks/network/te (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te() directly.
+
+ YANG Description: Indicates TE support.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te(self):
+ self.__te = YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ network_id = __builtin__.property(_get_network_id, _set_network_id)
+ network_types = __builtin__.property(_get_network_types, _set_network_types)
+ supporting_network = __builtin__.property(_get_supporting_network, _set_supporting_network)
+ node = __builtin__.property(_get_node, _set_node)
+ link = __builtin__.property(_get_link, _set_link)
+ te_topology_identifier = __builtin__.property(_get_te_topology_identifier, _set_te_topology_identifier)
+ te = __builtin__.property(_get_te, _set_te)
+
+
+ _pyangbind_elements = OrderedDict([('network_id', network_id), ('network_types', network_types), ('supporting_network', supporting_network), ('node', node), ('link', link), ('te_topology_identifier', te_topology_identifier), ('te', te), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..91937b156636c7db81427131959b4bc1ca33201c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/__init__.py
@@ -0,0 +1,294 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import source
+from . import destination
+from . import supporting_link
+from . import te
+class link(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A network link connects a local (source) node and
+a remote (destination) node via a set of the respective
+node's termination points. It is possible to have several
+links between the same source and destination nodes.
+Likewise, a link could potentially be re-homed between
+termination points. Therefore, in order to ensure that we
+would always know to distinguish between links, every link
+is identified by a dedicated link identifier. Note that a
+link models a point-to-point link, not a multipoint link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_id','__source','__destination','__supporting_link','__te',)
+
+ _yang_name = 'link'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_id = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='link-id', is_config=True)
+ self.__source = YANGDynClass(base=source.source, is_container='container', yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='container', is_config=True)
+ self.__destination = YANGDynClass(base=destination.destination, is_container='container', yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='container', is_config=True)
+ self.__supporting_link = YANGDynClass(base=YANGListType("network_ref link_ref",supporting_link.supporting_link, yang_name="supporting-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref link-ref', extensions=None), is_container='list', yang_name="supporting-link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)
+ self.__te = YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link']
+
+ def _get_link_id(self):
+ """
+ Getter method for link_id, mapped from YANG variable /networks/network/link/link_id (link-id)
+
+ YANG Description: The identifier of a link in the topology.
+A link is specific to a topology to which it belongs.
+ """
+ return self.__link_id
+
+ def _set_link_id(self, v, load=False):
+ """
+ Setter method for link_id, mapped from YANG variable /networks/network/link/link_id (link-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_id() directly.
+
+ YANG Description: The identifier of a link in the topology.
+A link is specific to a topology to which it belongs.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="link-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='link-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_id must be of a type compatible with link-id""",
+ 'defined-type': "ietf-network-topology:link-id",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='link-id', is_config=True)""",
+ })
+
+ self.__link_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_id(self):
+ self.__link_id = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='link-id', is_config=True)
+
+
+ def _get_source(self):
+ """
+ Getter method for source, mapped from YANG variable /networks/network/link/source (container)
+
+ YANG Description: This container holds the logical source of a particular
+link.
+ """
+ return self.__source
+
+ def _set_source(self, v, load=False):
+ """
+ Setter method for source, mapped from YANG variable /networks/network/link/source (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_source() directly.
+
+ YANG Description: This container holds the logical source of a particular
+link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=source.source, is_container='container', yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """source must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=source.source, is_container='container', yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_source(self):
+ self.__source = YANGDynClass(base=source.source, is_container='container', yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='container', is_config=True)
+
+
+ def _get_destination(self):
+ """
+ Getter method for destination, mapped from YANG variable /networks/network/link/destination (container)
+
+ YANG Description: This container holds the logical destination of a
+particular link.
+ """
+ return self.__destination
+
+ def _set_destination(self, v, load=False):
+ """
+ Setter method for destination, mapped from YANG variable /networks/network/link/destination (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_destination is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_destination() directly.
+
+ YANG Description: This container holds the logical destination of a
+particular link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=destination.destination, is_container='container', yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """destination must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=destination.destination, is_container='container', yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__destination = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_destination(self):
+ self.__destination = YANGDynClass(base=destination.destination, is_container='container', yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='container', is_config=True)
+
+
+ def _get_supporting_link(self):
+ """
+ Getter method for supporting_link, mapped from YANG variable /networks/network/link/supporting_link (list)
+
+ YANG Description: Identifies the link or links on which this link depends.
+ """
+ return self.__supporting_link
+
+ def _set_supporting_link(self, v, load=False):
+ """
+ Setter method for supporting_link, mapped from YANG variable /networks/network/link/supporting_link (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_supporting_link is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_supporting_link() directly.
+
+ YANG Description: Identifies the link or links on which this link depends.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("network_ref link_ref",supporting_link.supporting_link, yang_name="supporting-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref link-ref', extensions=None), is_container='list', yang_name="supporting-link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """supporting_link must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("network_ref link_ref",supporting_link.supporting_link, yang_name="supporting-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref link-ref', extensions=None), is_container='list', yang_name="supporting-link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__supporting_link = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_supporting_link(self):
+ self.__supporting_link = YANGDynClass(base=YANGListType("network_ref link_ref",supporting_link.supporting_link, yang_name="supporting-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref link-ref', extensions=None), is_container='list', yang_name="supporting-link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)
+
+
+ def _get_te(self):
+ """
+ Getter method for te, mapped from YANG variable /networks/network/link/te (container)
+
+ YANG Description: Indicates TE support.
+ """
+ return self.__te
+
+ def _set_te(self, v, load=False):
+ """
+ Setter method for te, mapped from YANG variable /networks/network/link/te (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te() directly.
+
+ YANG Description: Indicates TE support.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te(self):
+ self.__te = YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ link_id = __builtin__.property(_get_link_id, _set_link_id)
+ source = __builtin__.property(_get_source, _set_source)
+ destination = __builtin__.property(_get_destination, _set_destination)
+ supporting_link = __builtin__.property(_get_supporting_link, _set_supporting_link)
+ te = __builtin__.property(_get_te, _set_te)
+
+
+ _pyangbind_elements = OrderedDict([('link_id', link_id), ('source', source), ('destination', destination), ('supporting_link', supporting_link), ('te', te), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/destination/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/destination/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddab21c3e6976fac05cbe57124d8e58cc506539e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/destination/__init__.py
@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class destination(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/destination. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This container holds the logical destination of a
+particular link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__dest_node','__dest_tp',)
+
+ _yang_name = 'destination'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__dest_node = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="dest-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+ self.__dest_tp = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="dest-tp", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'destination']
+
+ def _get_dest_node(self):
+ """
+ Getter method for dest_node, mapped from YANG variable /networks/network/link/destination/dest_node (leafref)
+
+ YANG Description: Destination node identifier. Must be in the same
+network.
+ """
+ return self.__dest_node
+
+ def _set_dest_node(self, v, load=False):
+ """
+ Setter method for dest_node, mapped from YANG variable /networks/network/link/destination/dest_node (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_dest_node is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_dest_node() directly.
+
+ YANG Description: Destination node identifier. Must be in the same
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="dest-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """dest_node must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="dest-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__dest_node = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_dest_node(self):
+ self.__dest_node = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="dest-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_dest_tp(self):
+ """
+ Getter method for dest_tp, mapped from YANG variable /networks/network/link/destination/dest_tp (leafref)
+
+ YANG Description: This termination point is located within the
+destination node and terminates the link.
+ """
+ return self.__dest_tp
+
+ def _set_dest_tp(self, v, load=False):
+ """
+ Setter method for dest_tp, mapped from YANG variable /networks/network/link/destination/dest_tp (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_dest_tp is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_dest_tp() directly.
+
+ YANG Description: This termination point is located within the
+destination node and terminates the link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="dest-tp", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """dest_tp must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="dest-tp", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__dest_tp = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_dest_tp(self):
+ self.__dest_tp = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="dest-tp", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+
+ dest_node = __builtin__.property(_get_dest_node, _set_dest_node)
+ dest_tp = __builtin__.property(_get_dest_tp, _set_dest_tp)
+
+
+ _pyangbind_elements = OrderedDict([('dest_node', dest_node), ('dest_tp', dest_tp), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/source/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/source/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7538dfd44c5128d120b01b5018d9dd59cb97609c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/source/__init__.py
@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class source(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/source. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This container holds the logical source of a particular
+link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__source_node','__source_tp',)
+
+ _yang_name = 'source'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__source_node = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="source-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+ self.__source_tp = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="source-tp", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'source']
+
+ def _get_source_node(self):
+ """
+ Getter method for source_node, mapped from YANG variable /networks/network/link/source/source_node (leafref)
+
+ YANG Description: Source node identifier. Must be in the same topology.
+ """
+ return self.__source_node
+
+ def _set_source_node(self, v, load=False):
+ """
+ Setter method for source_node, mapped from YANG variable /networks/network/link/source/source_node (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_source_node is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_source_node() directly.
+
+ YANG Description: Source node identifier. Must be in the same topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="source-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """source_node must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="source-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__source_node = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_source_node(self):
+ self.__source_node = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="source-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_source_tp(self):
+ """
+ Getter method for source_tp, mapped from YANG variable /networks/network/link/source/source_tp (leafref)
+
+ YANG Description: This termination point is located within the source node
+and terminates the link.
+ """
+ return self.__source_tp
+
+ def _set_source_tp(self, v, load=False):
+ """
+ Setter method for source_tp, mapped from YANG variable /networks/network/link/source/source_tp (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_source_tp is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_source_tp() directly.
+
+ YANG Description: This termination point is located within the source node
+and terminates the link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="source-tp", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """source_tp must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="source-tp", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__source_tp = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_source_tp(self):
+ self.__source_tp = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="source-tp", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+
+ source_node = __builtin__.property(_get_source_node, _set_source_node)
+ source_tp = __builtin__.property(_get_source_tp, _set_source_tp)
+
+
+ _pyangbind_elements = OrderedDict([('source_node', source_node), ('source_tp', source_tp), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/supporting_link/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/supporting_link/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..28a780f5f61dfda6d026768a54c11b75e3d7fdb3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/supporting_link/__init__.py
@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class supporting_link(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/supporting-link. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Identifies the link or links on which this link depends.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref','__link_ref',)
+
+ _yang_name = 'supporting-link'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+ self.__link_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'supporting-link']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/link/supporting_link/network_ref (leafref)
+
+ YANG Description: This leaf identifies in which underlay topology
+the supporting link is present.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/link/supporting_link/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: This leaf identifies in which underlay topology
+the supporting link is present.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_link_ref(self):
+ """
+ Getter method for link_ref, mapped from YANG variable /networks/network/link/supporting_link/link_ref (leafref)
+
+ YANG Description: This leaf identifies a link that is a part
+of this link's underlay. Reference loops in which
+a link identifies itself as its underlay, either
+directly or transitively, are not allowed.
+ """
+ return self.__link_ref
+
+ def _set_link_ref(self, v, load=False):
+ """
+ Setter method for link_ref, mapped from YANG variable /networks/network/link/supporting_link/link_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_ref() directly.
+
+ YANG Description: This leaf identifies a link that is a part
+of this link's underlay. Reference loops in which
+a link identifies itself as its underlay, either
+directly or transitively, are not allowed.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__link_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_ref(self):
+ self.__link_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='leafref', is_config=True)
+
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ link_ref = __builtin__.property(_get_link_ref, _set_link_ref)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ('link_ref', link_ref), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..666d9718184c72f0d99ec5ed6e28adf8eed72cf4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/__init__.py
@@ -0,0 +1,603 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import bundled_links
+from . import component_links
+from . import te_link_attributes
+from . import information_source_state
+from . import information_source_entry
+from . import recovery
+from . import underlay
+from . import statistics
+class te(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Indicates TE support.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__bundled_links','__component_links','__te_link_template','__te_link_attributes','__oper_status','__is_transitional','__information_source','__information_source_instance','__information_source_state','__information_source_entry','__recovery','__underlay','__statistics',)
+
+ _yang_name = 'te'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__bundled_links = YANGDynClass(base=bundled_links.bundled_links, is_container='container', yang_name="bundled-links", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__component_links = YANGDynClass(base=component_links.component_links, is_container='container', yang_name="component-links", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__te_link_template = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="te-link-template", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__te_link_attributes = YANGDynClass(base=te_link_attributes.te_link_attributes, is_container='container', yang_name="te-link-attributes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__oper_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)
+ self.__is_transitional = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-transitional", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)
+ self.__information_source = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+ self.__information_source_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__information_source_state = YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__information_source_entry = YANGDynClass(base=YANGListType("information_source information_source_instance",information_source_entry.information_source_entry, yang_name="information-source-entry", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='information-source information-source-instance', extensions=None), is_container='list', yang_name="information-source-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__recovery = YANGDynClass(base=recovery.recovery, is_container='container', yang_name="recovery", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__statistics = YANGDynClass(base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te']
+
+ def _get_bundled_links(self):
+ """
+ Getter method for bundled_links, mapped from YANG variable /networks/network/link/te/bundled_links (container)
+
+ YANG Description: A set of bundled links.
+ """
+ return self.__bundled_links
+
+ def _set_bundled_links(self, v, load=False):
+ """
+ Setter method for bundled_links, mapped from YANG variable /networks/network/link/te/bundled_links (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_bundled_links is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_bundled_links() directly.
+
+ YANG Description: A set of bundled links.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=bundled_links.bundled_links, is_container='container', yang_name="bundled-links", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """bundled_links must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=bundled_links.bundled_links, is_container='container', yang_name="bundled-links", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__bundled_links = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_bundled_links(self):
+ self.__bundled_links = YANGDynClass(base=bundled_links.bundled_links, is_container='container', yang_name="bundled-links", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_component_links(self):
+ """
+ Getter method for component_links, mapped from YANG variable /networks/network/link/te/component_links (container)
+
+ YANG Description: A set of component links.
+ """
+ return self.__component_links
+
+ def _set_component_links(self, v, load=False):
+ """
+ Setter method for component_links, mapped from YANG variable /networks/network/link/te/component_links (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_component_links is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_component_links() directly.
+
+ YANG Description: A set of component links.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=component_links.component_links, is_container='container', yang_name="component-links", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """component_links must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=component_links.component_links, is_container='container', yang_name="component-links", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__component_links = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_component_links(self):
+ self.__component_links = YANGDynClass(base=component_links.component_links, is_container='container', yang_name="component-links", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_te_link_template(self):
+ """
+ Getter method for te_link_template, mapped from YANG variable /networks/network/link/te/te_link_template (leafref)
+
+ YANG Description: The reference to a TE link template.
+ """
+ return self.__te_link_template
+
+ def _set_te_link_template(self, v, load=False):
+ """
+ Setter method for te_link_template, mapped from YANG variable /networks/network/link/te/te_link_template (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_link_template is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_link_template() directly.
+
+ YANG Description: The reference to a TE link template.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="te-link-template", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_link_template must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="te-link-template", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__te_link_template = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_link_template(self):
+ self.__te_link_template = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="te-link-template", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_te_link_attributes(self):
+ """
+ Getter method for te_link_attributes, mapped from YANG variable /networks/network/link/te/te_link_attributes (container)
+
+ YANG Description: Link attributes in a TE topology.
+ """
+ return self.__te_link_attributes
+
+ def _set_te_link_attributes(self, v, load=False):
+ """
+ Setter method for te_link_attributes, mapped from YANG variable /networks/network/link/te/te_link_attributes (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_link_attributes is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_link_attributes() directly.
+
+ YANG Description: Link attributes in a TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_link_attributes.te_link_attributes, is_container='container', yang_name="te-link-attributes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_link_attributes must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_link_attributes.te_link_attributes, is_container='container', yang_name="te-link-attributes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_link_attributes = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_link_attributes(self):
+ self.__te_link_attributes = YANGDynClass(base=te_link_attributes.te_link_attributes, is_container='container', yang_name="te-link-attributes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_oper_status(self):
+ """
+ Getter method for oper_status, mapped from YANG variable /networks/network/link/te/oper_status (te-types:te-oper-status)
+
+ YANG Description: The current operational state of the link.
+ """
+ return self.__oper_status
+
+ def _set_oper_status(self, v, load=False):
+ """
+ Setter method for oper_status, mapped from YANG variable /networks/network/link/te/oper_status (te-types:te-oper-status)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_oper_status is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_oper_status() directly.
+
+ YANG Description: The current operational state of the link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """oper_status must be of a type compatible with te-types:te-oper-status""",
+ 'defined-type': "te-types:te-oper-status",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)""",
+ })
+
+ self.__oper_status = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_oper_status(self):
+ self.__oper_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)
+
+
+ def _get_is_transitional(self):
+ """
+ Getter method for is_transitional, mapped from YANG variable /networks/network/link/te/is_transitional (empty)
+
+ YANG Description: Present if the link is transitional; used as an
+alternative approach in lieu of 'inter-layer-lock-id'
+for path computation in a TE topology covering multiple
+layers or multiple regions.
+ """
+ return self.__is_transitional
+
+ def _set_is_transitional(self, v, load=False):
+ """
+ Setter method for is_transitional, mapped from YANG variable /networks/network/link/te/is_transitional (empty)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_transitional is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_transitional() directly.
+
+ YANG Description: Present if the link is transitional; used as an
+alternative approach in lieu of 'inter-layer-lock-id'
+for path computation in a TE topology covering multiple
+layers or multiple regions.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-transitional", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_transitional must be of a type compatible with empty""",
+ 'defined-type': "empty",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-transitional", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)""",
+ })
+
+ self.__is_transitional = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_transitional(self):
+ self.__is_transitional = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-transitional", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)
+
+
+ def _get_information_source(self):
+ """
+ Getter method for information_source, mapped from YANG variable /networks/network/link/te/information_source (te-info-source)
+
+ YANG Description: Indicates the type of information source.
+ """
+ return self.__information_source
+
+ def _set_information_source(self, v, load=False):
+ """
+ Setter method for information_source, mapped from YANG variable /networks/network/link/te/information_source (te-info-source)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source() directly.
+
+ YANG Description: Indicates the type of information source.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source must be of a type compatible with te-info-source""",
+ 'defined-type': "ietf-te-topology:te-info-source",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)""",
+ })
+
+ self.__information_source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source(self):
+ self.__information_source = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+
+
+ def _get_information_source_instance(self):
+ """
+ Getter method for information_source_instance, mapped from YANG variable /networks/network/link/te/information_source_instance (string)
+
+ YANG Description: The name indicating the instance of the information
+source.
+ """
+ return self.__information_source_instance
+
+ def _set_information_source_instance(self, v, load=False):
+ """
+ Setter method for information_source_instance, mapped from YANG variable /networks/network/link/te/information_source_instance (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source_instance is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source_instance() directly.
+
+ YANG Description: The name indicating the instance of the information
+source.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source_instance must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__information_source_instance = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source_instance(self):
+ self.__information_source_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_information_source_state(self):
+ """
+ Getter method for information_source_state, mapped from YANG variable /networks/network/link/te/information_source_state (container)
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ return self.__information_source_state
+
+ def _set_information_source_state(self, v, load=False):
+ """
+ Setter method for information_source_state, mapped from YANG variable /networks/network/link/te/information_source_state (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source_state is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source_state() directly.
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source_state must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__information_source_state = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source_state(self):
+ self.__information_source_state = YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_information_source_entry(self):
+ """
+ Getter method for information_source_entry, mapped from YANG variable /networks/network/link/te/information_source_entry (list)
+
+ YANG Description: A list of information sources learned, including the source
+that is used.
+ """
+ return self.__information_source_entry
+
+ def _set_information_source_entry(self, v, load=False):
+ """
+ Setter method for information_source_entry, mapped from YANG variable /networks/network/link/te/information_source_entry (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source_entry is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source_entry() directly.
+
+ YANG Description: A list of information sources learned, including the source
+that is used.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("information_source information_source_instance",information_source_entry.information_source_entry, yang_name="information-source-entry", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='information-source information-source-instance', extensions=None), is_container='list', yang_name="information-source-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source_entry must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("information_source information_source_instance",information_source_entry.information_source_entry, yang_name="information-source-entry", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='information-source information-source-instance', extensions=None), is_container='list', yang_name="information-source-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__information_source_entry = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source_entry(self):
+ self.__information_source_entry = YANGDynClass(base=YANGListType("information_source information_source_instance",information_source_entry.information_source_entry, yang_name="information-source-entry", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='information-source information-source-instance', extensions=None), is_container='list', yang_name="information-source-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_recovery(self):
+ """
+ Getter method for recovery, mapped from YANG variable /networks/network/link/te/recovery (container)
+
+ YANG Description: Status of the recovery process.
+ """
+ return self.__recovery
+
+ def _set_recovery(self, v, load=False):
+ """
+ Setter method for recovery, mapped from YANG variable /networks/network/link/te/recovery (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_recovery is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_recovery() directly.
+
+ YANG Description: Status of the recovery process.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=recovery.recovery, is_container='container', yang_name="recovery", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """recovery must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=recovery.recovery, is_container='container', yang_name="recovery", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__recovery = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_recovery(self):
+ self.__recovery = YANGDynClass(base=recovery.recovery, is_container='container', yang_name="recovery", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_underlay(self):
+ """
+ Getter method for underlay, mapped from YANG variable /networks/network/link/te/underlay (container)
+
+ YANG Description: State attributes for the TE link underlay.
+ """
+ return self.__underlay
+
+ def _set_underlay(self, v, load=False):
+ """
+ Setter method for underlay, mapped from YANG variable /networks/network/link/te/underlay (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_underlay is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_underlay() directly.
+
+ YANG Description: State attributes for the TE link underlay.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """underlay must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__underlay = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_underlay(self):
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_statistics(self):
+ """
+ Getter method for statistics, mapped from YANG variable /networks/network/link/te/statistics (container)
+
+ YANG Description: Statistics data.
+ """
+ return self.__statistics
+
+ def _set_statistics(self, v, load=False):
+ """
+ Setter method for statistics, mapped from YANG variable /networks/network/link/te/statistics (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_statistics is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_statistics() directly.
+
+ YANG Description: Statistics data.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """statistics must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__statistics = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_statistics(self):
+ self.__statistics = YANGDynClass(base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ bundled_links = __builtin__.property(_get_bundled_links, _set_bundled_links)
+ component_links = __builtin__.property(_get_component_links, _set_component_links)
+ te_link_template = __builtin__.property(_get_te_link_template, _set_te_link_template)
+ te_link_attributes = __builtin__.property(_get_te_link_attributes, _set_te_link_attributes)
+ oper_status = __builtin__.property(_get_oper_status)
+ is_transitional = __builtin__.property(_get_is_transitional)
+ information_source = __builtin__.property(_get_information_source)
+ information_source_instance = __builtin__.property(_get_information_source_instance)
+ information_source_state = __builtin__.property(_get_information_source_state)
+ information_source_entry = __builtin__.property(_get_information_source_entry)
+ recovery = __builtin__.property(_get_recovery)
+ underlay = __builtin__.property(_get_underlay)
+ statistics = __builtin__.property(_get_statistics)
+
+ __choices__ = {'bundle-stack-level': {'bundle': ['bundled_links'], 'component': ['component_links']}}
+ _pyangbind_elements = OrderedDict([('bundled_links', bundled_links), ('component_links', component_links), ('te_link_template', te_link_template), ('te_link_attributes', te_link_attributes), ('oper_status', oper_status), ('is_transitional', is_transitional), ('information_source', information_source), ('information_source_instance', information_source_instance), ('information_source_state', information_source_state), ('information_source_entry', information_source_entry), ('recovery', recovery), ('underlay', underlay), ('statistics', statistics), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/bundled_links/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/bundled_links/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..890484652415def2558181690b85a15e6a71258a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/bundled_links/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import bundled_link
+class bundled_links(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/bundled-links. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A set of bundled links.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__bundled_link',)
+
+ _yang_name = 'bundled-links'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__bundled_link = YANGDynClass(base=YANGListType("sequence",bundled_link.bundled_link, yang_name="bundled-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='sequence', extensions=None, choice=('bundle-stack-level', 'bundle')), is_container='list', yang_name="bundled-link", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'bundled-links']
+
+ def _get_bundled_link(self):
+ """
+ Getter method for bundled_link, mapped from YANG variable /networks/network/link/te/bundled_links/bundled_link (list)
+
+ YANG Description: Specifies a bundled interface that is
+further partitioned.
+ """
+ return self.__bundled_link
+
+ def _set_bundled_link(self, v, load=False):
+ """
+ Setter method for bundled_link, mapped from YANG variable /networks/network/link/te/bundled_links/bundled_link (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_bundled_link is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_bundled_link() directly.
+
+ YANG Description: Specifies a bundled interface that is
+further partitioned.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("sequence",bundled_link.bundled_link, yang_name="bundled-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='sequence', extensions=None, choice=('bundle-stack-level', 'bundle')), is_container='list', yang_name="bundled-link", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """bundled_link must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("sequence",bundled_link.bundled_link, yang_name="bundled-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='sequence', extensions=None, choice=('bundle-stack-level', 'bundle')), is_container='list', yang_name="bundled-link", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__bundled_link = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_bundled_link(self):
+ self.__bundled_link = YANGDynClass(base=YANGListType("sequence",bundled_link.bundled_link, yang_name="bundled-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='sequence', extensions=None, choice=('bundle-stack-level', 'bundle')), is_container='list', yang_name="bundled-link", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ bundled_link = __builtin__.property(_get_bundled_link, _set_bundled_link)
+
+ __choices__ = {'bundle-stack-level': {'bundle': ['bundled_link']}}
+ _pyangbind_elements = OrderedDict([('bundled_link', bundled_link), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/bundled_links/bundled_link/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/bundled_links/bundled_link/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..99c0b71fe3c0da96681858df66cd8771b0ffb326
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/bundled_links/bundled_link/__init__.py
@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class bundled_link(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/bundled-links/bundled-link. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Specifies a bundled interface that is
+further partitioned.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__sequence','__src_tp_ref','__des_tp_ref',)
+
+ _yang_name = 'bundled-link'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__sequence = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="sequence", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__src_tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="src-tp-ref", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__des_tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="des-tp-ref", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'bundled-links', 'bundled-link']
+
+ def _get_sequence(self):
+ """
+ Getter method for sequence, mapped from YANG variable /networks/network/link/te/bundled_links/bundled_link/sequence (uint32)
+
+ YANG Description: Identifies the sequence in the bundle.
+ """
+ return self.__sequence
+
+ def _set_sequence(self, v, load=False):
+ """
+ Setter method for sequence, mapped from YANG variable /networks/network/link/te/bundled_links/bundled_link/sequence (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sequence is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sequence() directly.
+
+ YANG Description: Identifies the sequence in the bundle.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="sequence", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sequence must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="sequence", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__sequence = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sequence(self):
+ self.__sequence = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="sequence", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_src_tp_ref(self):
+ """
+ Getter method for src_tp_ref, mapped from YANG variable /networks/network/link/te/bundled_links/bundled_link/src_tp_ref (leafref)
+
+ YANG Description: Reference to another TE termination point on the
+same source node.
+ """
+ return self.__src_tp_ref
+
+ def _set_src_tp_ref(self, v, load=False):
+ """
+ Setter method for src_tp_ref, mapped from YANG variable /networks/network/link/te/bundled_links/bundled_link/src_tp_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_src_tp_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_src_tp_ref() directly.
+
+ YANG Description: Reference to another TE termination point on the
+same source node.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="src-tp-ref", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """src_tp_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="src-tp-ref", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__src_tp_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_src_tp_ref(self):
+ self.__src_tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="src-tp-ref", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_des_tp_ref(self):
+ """
+ Getter method for des_tp_ref, mapped from YANG variable /networks/network/link/te/bundled_links/bundled_link/des_tp_ref (leafref)
+
+ YANG Description: Reference to another TE termination point on the
+same destination node.
+ """
+ return self.__des_tp_ref
+
+ def _set_des_tp_ref(self, v, load=False):
+ """
+ Setter method for des_tp_ref, mapped from YANG variable /networks/network/link/te/bundled_links/bundled_link/des_tp_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_des_tp_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_des_tp_ref() directly.
+
+ YANG Description: Reference to another TE termination point on the
+same destination node.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="des-tp-ref", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """des_tp_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="des-tp-ref", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__des_tp_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_des_tp_ref(self):
+ self.__des_tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="des-tp-ref", parent=self, choice=('bundle-stack-level', 'bundle'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+ sequence = __builtin__.property(_get_sequence, _set_sequence)
+ src_tp_ref = __builtin__.property(_get_src_tp_ref, _set_src_tp_ref)
+ des_tp_ref = __builtin__.property(_get_des_tp_ref, _set_des_tp_ref)
+
+ __choices__ = {'bundle-stack-level': {'bundle': ['sequence', 'src_tp_ref', 'des_tp_ref']}}
+ _pyangbind_elements = OrderedDict([('sequence', sequence), ('src_tp_ref', src_tp_ref), ('des_tp_ref', des_tp_ref), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/component_links/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/component_links/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2207417bc3b9a0271d4b08634647ae9d538f9724
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/component_links/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import component_link
+class component_links(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/component-links. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A set of component links.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__component_link',)
+
+ _yang_name = 'component-links'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__component_link = YANGDynClass(base=YANGListType("sequence",component_link.component_link, yang_name="component-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='sequence', extensions=None, choice=('bundle-stack-level', 'component')), is_container='list', yang_name="component-link", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'component-links']
+
+ def _get_component_link(self):
+ """
+ Getter method for component_link, mapped from YANG variable /networks/network/link/te/component_links/component_link (list)
+
+ YANG Description: Specifies a component interface that is
+sufficient to unambiguously identify the
+appropriate resources.
+ """
+ return self.__component_link
+
+ def _set_component_link(self, v, load=False):
+ """
+ Setter method for component_link, mapped from YANG variable /networks/network/link/te/component_links/component_link (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_component_link is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_component_link() directly.
+
+ YANG Description: Specifies a component interface that is
+sufficient to unambiguously identify the
+appropriate resources.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("sequence",component_link.component_link, yang_name="component-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='sequence', extensions=None, choice=('bundle-stack-level', 'component')), is_container='list', yang_name="component-link", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """component_link must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("sequence",component_link.component_link, yang_name="component-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='sequence', extensions=None, choice=('bundle-stack-level', 'component')), is_container='list', yang_name="component-link", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__component_link = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_component_link(self):
+ self.__component_link = YANGDynClass(base=YANGListType("sequence",component_link.component_link, yang_name="component-link", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='sequence', extensions=None, choice=('bundle-stack-level', 'component')), is_container='list', yang_name="component-link", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ component_link = __builtin__.property(_get_component_link, _set_component_link)
+
+ __choices__ = {'bundle-stack-level': {'component': ['component_link']}}
+ _pyangbind_elements = OrderedDict([('component_link', component_link), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/component_links/component_link/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/component_links/component_link/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5995318d715c909846c2ed74a6ddb881cbb7689f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/component_links/component_link/__init__.py
@@ -0,0 +1,204 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class component_link(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/component-links/component-link. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Specifies a component interface that is
+sufficient to unambiguously identify the
+appropriate resources.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__sequence','__src_interface_ref','__des_interface_ref',)
+
+ _yang_name = 'component-link'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__sequence = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="sequence", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__src_interface_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="src-interface-ref", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ self.__des_interface_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="des-interface-ref", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'component-links', 'component-link']
+
+ def _get_sequence(self):
+ """
+ Getter method for sequence, mapped from YANG variable /networks/network/link/te/component_links/component_link/sequence (uint32)
+
+ YANG Description: Identifies the sequence in the bundle.
+ """
+ return self.__sequence
+
+ def _set_sequence(self, v, load=False):
+ """
+ Setter method for sequence, mapped from YANG variable /networks/network/link/te/component_links/component_link/sequence (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sequence is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sequence() directly.
+
+ YANG Description: Identifies the sequence in the bundle.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="sequence", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sequence must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="sequence", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__sequence = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sequence(self):
+ self.__sequence = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="sequence", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_src_interface_ref(self):
+ """
+ Getter method for src_interface_ref, mapped from YANG variable /networks/network/link/te/component_links/component_link/src_interface_ref (string)
+
+ YANG Description: Reference to a component link interface on the
+source node.
+ """
+ return self.__src_interface_ref
+
+ def _set_src_interface_ref(self, v, load=False):
+ """
+ Setter method for src_interface_ref, mapped from YANG variable /networks/network/link/te/component_links/component_link/src_interface_ref (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_src_interface_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_src_interface_ref() directly.
+
+ YANG Description: Reference to a component link interface on the
+source node.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="src-interface-ref", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """src_interface_ref must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="src-interface-ref", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__src_interface_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_src_interface_ref(self):
+ self.__src_interface_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="src-interface-ref", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+
+ def _get_des_interface_ref(self):
+ """
+ Getter method for des_interface_ref, mapped from YANG variable /networks/network/link/te/component_links/component_link/des_interface_ref (string)
+
+ YANG Description: Reference to a component link interface on the
+destination node.
+ """
+ return self.__des_interface_ref
+
+ def _set_des_interface_ref(self, v, load=False):
+ """
+ Setter method for des_interface_ref, mapped from YANG variable /networks/network/link/te/component_links/component_link/des_interface_ref (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_des_interface_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_des_interface_ref() directly.
+
+ YANG Description: Reference to a component link interface on the
+destination node.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="des-interface-ref", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """des_interface_ref must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="des-interface-ref", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__des_interface_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_des_interface_ref(self):
+ self.__des_interface_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="des-interface-ref", parent=self, choice=('bundle-stack-level', 'component'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ sequence = __builtin__.property(_get_sequence, _set_sequence)
+ src_interface_ref = __builtin__.property(_get_src_interface_ref, _set_src_interface_ref)
+ des_interface_ref = __builtin__.property(_get_des_interface_ref, _set_des_interface_ref)
+
+ __choices__ = {'bundle-stack-level': {'component': ['sequence', 'src_interface_ref', 'des_interface_ref']}}
+ _pyangbind_elements = OrderedDict([('sequence', sequence), ('src_interface_ref', src_interface_ref), ('des_interface_ref', des_interface_ref), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d331b67df85fe3f0c3173f74307de38fa5bc5d0b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/__init__.py
@@ -0,0 +1,749 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import information_source_state
+from . import interface_switching_capability
+from . import label_restrictions
+from . import max_link_bandwidth
+from . import max_resv_link_bandwidth
+from . import unreserved_bandwidth
+from . import te_srlgs
+from . import te_nsrlgs
+class information_source_entry(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of information sources learned, including the source
+that is used.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__information_source','__information_source_instance','__information_source_state','__link_index','__administrative_group','__interface_switching_capability','__label_restrictions','__link_protection_type','__max_link_bandwidth','__max_resv_link_bandwidth','__unreserved_bandwidth','__te_default_metric','__te_delay_metric','__te_igp_metric','__te_srlgs','__te_nsrlgs',)
+
+ _yang_name = 'information-source-entry'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__information_source = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+ self.__information_source_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__information_source_state = YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__link_index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="link-index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+ self.__administrative_group = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], is_leaf=True, yang_name="administrative-group", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:admin-groups', is_config=False)
+ self.__interface_switching_capability = YANGDynClass(base=YANGListType("switching_capability encoding",interface_switching_capability.interface_switching_capability, yang_name="interface-switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="interface-switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__link_protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="link-protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__max_link_bandwidth = YANGDynClass(base=max_link_bandwidth.max_link_bandwidth, is_container='container', yang_name="max-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__max_resv_link_bandwidth = YANGDynClass(base=max_resv_link_bandwidth.max_resv_link_bandwidth, is_container='container', yang_name="max-resv-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unreserved_bandwidth = YANGDynClass(base=YANGListType("priority",unreserved_bandwidth.unreserved_bandwidth, yang_name="unreserved-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="unreserved-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__te_default_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-default-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__te_delay_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-delay-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__te_igp_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-igp-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__te_srlgs = YANGDynClass(base=te_srlgs.te_srlgs, is_container='container', yang_name="te-srlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__te_nsrlgs = YANGDynClass(base=te_nsrlgs.te_nsrlgs, is_container='container', yang_name="te-nsrlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry']
+
+ def _get_information_source(self):
+ """
+ Getter method for information_source, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source (te-info-source)
+
+ YANG Description: Indicates the type of information source.
+ """
+ return self.__information_source
+
+ def _set_information_source(self, v, load=False):
+ """
+ Setter method for information_source, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source (te-info-source)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source() directly.
+
+ YANG Description: Indicates the type of information source.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source must be of a type compatible with te-info-source""",
+ 'defined-type': "ietf-te-topology:te-info-source",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)""",
+ })
+
+ self.__information_source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source(self):
+ self.__information_source = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+
+
+ def _get_information_source_instance(self):
+ """
+ Getter method for information_source_instance, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_instance (string)
+
+ YANG Description: The name indicating the instance of the information
+source.
+ """
+ return self.__information_source_instance
+
+ def _set_information_source_instance(self, v, load=False):
+ """
+ Setter method for information_source_instance, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_instance (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source_instance is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source_instance() directly.
+
+ YANG Description: The name indicating the instance of the information
+source.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source_instance must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__information_source_instance = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source_instance(self):
+ self.__information_source_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_information_source_state(self):
+ """
+ Getter method for information_source_state, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state (container)
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ return self.__information_source_state
+
+ def _set_information_source_state(self, v, load=False):
+ """
+ Setter method for information_source_state, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source_state is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source_state() directly.
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source_state must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__information_source_state = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source_state(self):
+ self.__information_source_state = YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_link_index(self):
+ """
+ Getter method for link_index, mapped from YANG variable /networks/network/link/te/information_source_entry/link_index (uint64)
+
+ YANG Description: The link identifier. If OSPF is used, this object
+represents an ospfLsdbID. If IS-IS is used, this object
+represents an isisLSPID. If a locally configured link is
+used, this object represents a unique value, which is
+locally defined in a router.
+ """
+ return self.__link_index
+
+ def _set_link_index(self, v, load=False):
+ """
+ Setter method for link_index, mapped from YANG variable /networks/network/link/te/information_source_entry/link_index (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_index() directly.
+
+ YANG Description: The link identifier. If OSPF is used, this object
+represents an ospfLsdbID. If IS-IS is used, this object
+represents an isisLSPID. If a locally configured link is
+used, this object represents a unique value, which is
+locally defined in a router.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="link-index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_index must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="link-index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__link_index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_index(self):
+ self.__link_index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="link-index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+
+ def _get_administrative_group(self):
+ """
+ Getter method for administrative_group, mapped from YANG variable /networks/network/link/te/information_source_entry/administrative_group (te-types:admin-groups)
+
+ YANG Description: Administrative group or color of the link.
+This attribute covers both administrative groups (defined
+in RFCs 3630 and 5305) and Extended Administrative Groups
+(defined in RFC 7308).
+ """
+ return self.__administrative_group
+
+ def _set_administrative_group(self, v, load=False):
+ """
+ Setter method for administrative_group, mapped from YANG variable /networks/network/link/te/information_source_entry/administrative_group (te-types:admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_administrative_group is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_administrative_group() directly.
+
+ YANG Description: Administrative group or color of the link.
+This attribute covers both administrative groups (defined
+in RFCs 3630 and 5305) and Extended Administrative Groups
+(defined in RFC 7308).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], is_leaf=True, yang_name="administrative-group", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:admin-groups', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """administrative_group must be of a type compatible with te-types:admin-groups""",
+ 'defined-type': "te-types:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], is_leaf=True, yang_name="administrative-group", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:admin-groups', is_config=False)""",
+ })
+
+ self.__administrative_group = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_administrative_group(self):
+ self.__administrative_group = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], is_leaf=True, yang_name="administrative-group", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:admin-groups', is_config=False)
+
+
+ def _get_interface_switching_capability(self):
+ """
+ Getter method for interface_switching_capability, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability (list)
+
+ YANG Description: List of ISCDs for this link.
+ """
+ return self.__interface_switching_capability
+
+ def _set_interface_switching_capability(self, v, load=False):
+ """
+ Setter method for interface_switching_capability, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_interface_switching_capability is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_interface_switching_capability() directly.
+
+ YANG Description: List of ISCDs for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("switching_capability encoding",interface_switching_capability.interface_switching_capability, yang_name="interface-switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="interface-switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """interface_switching_capability must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("switching_capability encoding",interface_switching_capability.interface_switching_capability, yang_name="interface-switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="interface-switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__interface_switching_capability = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_interface_switching_capability(self):
+ self.__interface_switching_capability = YANGDynClass(base=YANGListType("switching_capability encoding",interface_switching_capability.interface_switching_capability, yang_name="interface-switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="interface-switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_label_restrictions(self):
+ """
+ Getter method for label_restrictions, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions (container)
+
+ YANG Description: The label restrictions container.
+ """
+ return self.__label_restrictions
+
+ def _set_label_restrictions(self, v, load=False):
+ """
+ Setter method for label_restrictions, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restrictions is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restrictions() directly.
+
+ YANG Description: The label restrictions container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restrictions must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_restrictions = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restrictions(self):
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_link_protection_type(self):
+ """
+ Getter method for link_protection_type, mapped from YANG variable /networks/network/link/te/information_source_entry/link_protection_type (identityref)
+
+ YANG Description: Link Protection Type desired for this link.
+ """
+ return self.__link_protection_type
+
+ def _set_link_protection_type(self, v, load=False):
+ """
+ Setter method for link_protection_type, mapped from YANG variable /networks/network/link/te/information_source_entry/link_protection_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_protection_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_protection_type() directly.
+
+ YANG Description: Link Protection Type desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="link-protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_protection_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="link-protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__link_protection_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_protection_type(self):
+ self.__link_protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="link-protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_max_link_bandwidth(self):
+ """
+ Getter method for max_link_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth (container)
+
+ YANG Description: Maximum bandwidth that can be seen on this link in this
+direction. Units are in bytes per second.
+ """
+ return self.__max_link_bandwidth
+
+ def _set_max_link_bandwidth(self, v, load=False):
+ """
+ Setter method for max_link_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_max_link_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_max_link_bandwidth() directly.
+
+ YANG Description: Maximum bandwidth that can be seen on this link in this
+direction. Units are in bytes per second.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=max_link_bandwidth.max_link_bandwidth, is_container='container', yang_name="max-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """max_link_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=max_link_bandwidth.max_link_bandwidth, is_container='container', yang_name="max-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__max_link_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_max_link_bandwidth(self):
+ self.__max_link_bandwidth = YANGDynClass(base=max_link_bandwidth.max_link_bandwidth, is_container='container', yang_name="max-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_max_resv_link_bandwidth(self):
+ """
+ Getter method for max_resv_link_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth (container)
+
+ YANG Description: Maximum amount of bandwidth that can be reserved in this
+direction in this link. Units are in bytes per second.
+ """
+ return self.__max_resv_link_bandwidth
+
+ def _set_max_resv_link_bandwidth(self, v, load=False):
+ """
+ Setter method for max_resv_link_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_max_resv_link_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_max_resv_link_bandwidth() directly.
+
+ YANG Description: Maximum amount of bandwidth that can be reserved in this
+direction in this link. Units are in bytes per second.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=max_resv_link_bandwidth.max_resv_link_bandwidth, is_container='container', yang_name="max-resv-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """max_resv_link_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=max_resv_link_bandwidth.max_resv_link_bandwidth, is_container='container', yang_name="max-resv-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__max_resv_link_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_max_resv_link_bandwidth(self):
+ self.__max_resv_link_bandwidth = YANGDynClass(base=max_resv_link_bandwidth.max_resv_link_bandwidth, is_container='container', yang_name="max-resv-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unreserved_bandwidth(self):
+ """
+ Getter method for unreserved_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth (list)
+
+ YANG Description: Unreserved bandwidth for priority levels 0-7. Units are in
+bytes per second.
+ """
+ return self.__unreserved_bandwidth
+
+ def _set_unreserved_bandwidth(self, v, load=False):
+ """
+ Setter method for unreserved_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unreserved_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unreserved_bandwidth() directly.
+
+ YANG Description: Unreserved bandwidth for priority levels 0-7. Units are in
+bytes per second.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("priority",unreserved_bandwidth.unreserved_bandwidth, yang_name="unreserved-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="unreserved-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unreserved_bandwidth must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("priority",unreserved_bandwidth.unreserved_bandwidth, yang_name="unreserved-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="unreserved-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__unreserved_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unreserved_bandwidth(self):
+ self.__unreserved_bandwidth = YANGDynClass(base=YANGListType("priority",unreserved_bandwidth.unreserved_bandwidth, yang_name="unreserved-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="unreserved-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_te_default_metric(self):
+ """
+ Getter method for te_default_metric, mapped from YANG variable /networks/network/link/te/information_source_entry/te_default_metric (uint32)
+
+ YANG Description: Traffic Engineering metric.
+ """
+ return self.__te_default_metric
+
+ def _set_te_default_metric(self, v, load=False):
+ """
+ Setter method for te_default_metric, mapped from YANG variable /networks/network/link/te/information_source_entry/te_default_metric (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_default_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_default_metric() directly.
+
+ YANG Description: Traffic Engineering metric.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-default-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_default_metric must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-default-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__te_default_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_default_metric(self):
+ self.__te_default_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-default-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_te_delay_metric(self):
+ """
+ Getter method for te_delay_metric, mapped from YANG variable /networks/network/link/te/information_source_entry/te_delay_metric (uint32)
+
+ YANG Description: Traffic Engineering delay metric.
+ """
+ return self.__te_delay_metric
+
+ def _set_te_delay_metric(self, v, load=False):
+ """
+ Setter method for te_delay_metric, mapped from YANG variable /networks/network/link/te/information_source_entry/te_delay_metric (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_delay_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_delay_metric() directly.
+
+ YANG Description: Traffic Engineering delay metric.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-delay-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_delay_metric must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-delay-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__te_delay_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_delay_metric(self):
+ self.__te_delay_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-delay-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_te_igp_metric(self):
+ """
+ Getter method for te_igp_metric, mapped from YANG variable /networks/network/link/te/information_source_entry/te_igp_metric (uint32)
+
+ YANG Description: IGP metric used for Traffic Engineering.
+ """
+ return self.__te_igp_metric
+
+ def _set_te_igp_metric(self, v, load=False):
+ """
+ Setter method for te_igp_metric, mapped from YANG variable /networks/network/link/te/information_source_entry/te_igp_metric (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_igp_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_igp_metric() directly.
+
+ YANG Description: IGP metric used for Traffic Engineering.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-igp-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_igp_metric must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-igp-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__te_igp_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_igp_metric(self):
+ self.__te_igp_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-igp-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_te_srlgs(self):
+ """
+ Getter method for te_srlgs, mapped from YANG variable /networks/network/link/te/information_source_entry/te_srlgs (container)
+
+ YANG Description: Contains a list of SRLGs.
+ """
+ return self.__te_srlgs
+
+ def _set_te_srlgs(self, v, load=False):
+ """
+ Setter method for te_srlgs, mapped from YANG variable /networks/network/link/te/information_source_entry/te_srlgs (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_srlgs is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_srlgs() directly.
+
+ YANG Description: Contains a list of SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_srlgs.te_srlgs, is_container='container', yang_name="te-srlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_srlgs must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_srlgs.te_srlgs, is_container='container', yang_name="te-srlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_srlgs = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_srlgs(self):
+ self.__te_srlgs = YANGDynClass(base=te_srlgs.te_srlgs, is_container='container', yang_name="te-srlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_te_nsrlgs(self):
+ """
+ Getter method for te_nsrlgs, mapped from YANG variable /networks/network/link/te/information_source_entry/te_nsrlgs (container)
+
+ YANG Description: Contains a list of NSRLGs (Non-Shared Risk Link Groups).
+When an abstract TE link is configured, this list specifies
+the request that underlay TE paths need to be mutually
+disjoint with other TE links in the same groups.
+ """
+ return self.__te_nsrlgs
+
+ def _set_te_nsrlgs(self, v, load=False):
+ """
+ Setter method for te_nsrlgs, mapped from YANG variable /networks/network/link/te/information_source_entry/te_nsrlgs (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_nsrlgs is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_nsrlgs() directly.
+
+ YANG Description: Contains a list of NSRLGs (Non-Shared Risk Link Groups).
+When an abstract TE link is configured, this list specifies
+the request that underlay TE paths need to be mutually
+disjoint with other TE links in the same groups.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_nsrlgs.te_nsrlgs, is_container='container', yang_name="te-nsrlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_nsrlgs must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_nsrlgs.te_nsrlgs, is_container='container', yang_name="te-nsrlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_nsrlgs = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_nsrlgs(self):
+ self.__te_nsrlgs = YANGDynClass(base=te_nsrlgs.te_nsrlgs, is_container='container', yang_name="te-nsrlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ information_source = __builtin__.property(_get_information_source)
+ information_source_instance = __builtin__.property(_get_information_source_instance)
+ information_source_state = __builtin__.property(_get_information_source_state)
+ link_index = __builtin__.property(_get_link_index)
+ administrative_group = __builtin__.property(_get_administrative_group)
+ interface_switching_capability = __builtin__.property(_get_interface_switching_capability)
+ label_restrictions = __builtin__.property(_get_label_restrictions)
+ link_protection_type = __builtin__.property(_get_link_protection_type)
+ max_link_bandwidth = __builtin__.property(_get_max_link_bandwidth)
+ max_resv_link_bandwidth = __builtin__.property(_get_max_resv_link_bandwidth)
+ unreserved_bandwidth = __builtin__.property(_get_unreserved_bandwidth)
+ te_default_metric = __builtin__.property(_get_te_default_metric)
+ te_delay_metric = __builtin__.property(_get_te_delay_metric)
+ te_igp_metric = __builtin__.property(_get_te_igp_metric)
+ te_srlgs = __builtin__.property(_get_te_srlgs)
+ te_nsrlgs = __builtin__.property(_get_te_nsrlgs)
+
+
+ _pyangbind_elements = OrderedDict([('information_source', information_source), ('information_source_instance', information_source_instance), ('information_source_state', information_source_state), ('link_index', link_index), ('administrative_group', administrative_group), ('interface_switching_capability', interface_switching_capability), ('label_restrictions', label_restrictions), ('link_protection_type', link_protection_type), ('max_link_bandwidth', max_link_bandwidth), ('max_resv_link_bandwidth', max_resv_link_bandwidth), ('unreserved_bandwidth', unreserved_bandwidth), ('te_default_metric', te_default_metric), ('te_delay_metric', te_delay_metric), ('te_igp_metric', te_igp_metric), ('te_srlgs', te_srlgs), ('te_nsrlgs', te_nsrlgs), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/information_source_state/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/information_source_state/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..51885bb49b9eb9a0279b8ff45e62449f896c03ef
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/information_source_state/__init__.py
@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import topology
+class information_source_state(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/information-source-state. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__credibility_preference','__logical_network_element','__network_instance','__topology',)
+
+ _yang_name = 'information-source-state'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__credibility_preference = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+ self.__logical_network_element = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__network_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__topology = YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'information-source-state']
+
+ def _get_credibility_preference(self):
+ """
+ Getter method for credibility_preference, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/credibility_preference (uint16)
+
+ YANG Description: The preference value for calculating the Traffic
+Engineering database credibility value used for
+tie-break selection between different information-source
+values. A higher value is preferable.
+ """
+ return self.__credibility_preference
+
+ def _set_credibility_preference(self, v, load=False):
+ """
+ Setter method for credibility_preference, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/credibility_preference (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_credibility_preference is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_credibility_preference() directly.
+
+ YANG Description: The preference value for calculating the Traffic
+Engineering database credibility value used for
+tie-break selection between different information-source
+values. A higher value is preferable.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """credibility_preference must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__credibility_preference = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_credibility_preference(self):
+ self.__credibility_preference = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+
+
+ def _get_logical_network_element(self):
+ """
+ Getter method for logical_network_element, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/logical_network_element (string)
+
+ YANG Description: When applicable, this is the name of a logical network
+element from which the information is learned.
+ """
+ return self.__logical_network_element
+
+ def _set_logical_network_element(self, v, load=False):
+ """
+ Setter method for logical_network_element, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/logical_network_element (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_logical_network_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_logical_network_element() directly.
+
+ YANG Description: When applicable, this is the name of a logical network
+element from which the information is learned.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """logical_network_element must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__logical_network_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_logical_network_element(self):
+ self.__logical_network_element = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_network_instance(self):
+ """
+ Getter method for network_instance, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/network_instance (string)
+
+ YANG Description: When applicable, this is the name of a network instance
+from which the information is learned.
+ """
+ return self.__network_instance
+
+ def _set_network_instance(self, v, load=False):
+ """
+ Setter method for network_instance, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/network_instance (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_instance is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_instance() directly.
+
+ YANG Description: When applicable, this is the name of a network instance
+from which the information is learned.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_instance must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__network_instance = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_instance(self):
+ self.__network_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_topology(self):
+ """
+ Getter method for topology, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/topology (container)
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ return self.__topology
+
+ def _set_topology(self, v, load=False):
+ """
+ Setter method for topology, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/topology (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_topology is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_topology() directly.
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """topology must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__topology = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_topology(self):
+ self.__topology = YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ credibility_preference = __builtin__.property(_get_credibility_preference)
+ logical_network_element = __builtin__.property(_get_logical_network_element)
+ network_instance = __builtin__.property(_get_network_instance)
+ topology = __builtin__.property(_get_topology)
+
+
+ _pyangbind_elements = OrderedDict([('credibility_preference', credibility_preference), ('logical_network_element', logical_network_element), ('network_instance', network_instance), ('topology', topology), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/information_source_state/topology/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/information_source_state/topology/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c611a8e1a8ca42bd8fd0e26b2027e038f96a3a0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/information_source_state/topology/__init__.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/information-source-state/topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_ref','__network_ref',)
+
+ _yang_name = 'topology'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'information-source-state', 'topology']
+
+ def _get_link_ref(self):
+ """
+ Getter method for link_ref, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/topology/link_ref (leafref)
+
+ YANG Description: A type for an absolute reference to a link instance.
+(This type should not be used for relative references.
+In such a case, a relative path should be used instead.)
+ """
+ return self.__link_ref
+
+ def _set_link_ref(self, v, load=False):
+ """
+ Setter method for link_ref, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/topology/link_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_ref() directly.
+
+ YANG Description: A type for an absolute reference to a link instance.
+(This type should not be used for relative references.
+In such a case, a relative path should be used instead.)
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__link_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_ref(self):
+ self.__link_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/topology/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/link/te/information_source_entry/information_source_state/topology/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+ link_ref = __builtin__.property(_get_link_ref)
+ network_ref = __builtin__.property(_get_network_ref)
+
+
+ _pyangbind_elements = OrderedDict([('link_ref', link_ref), ('network_ref', network_ref), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..55c5599b7241e9668f3e096676957d5d85559d6e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/__init__.py
@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import max_lsp_bandwidth
+class interface_switching_capability(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/interface-switching-capability. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of ISCDs for this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__switching_capability','__encoding','__max_lsp_bandwidth',)
+
+ _yang_name = 'interface-switching-capability'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__switching_capability = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__encoding = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__max_lsp_bandwidth = YANGDynClass(base=YANGListType("priority",max_lsp_bandwidth.max_lsp_bandwidth, yang_name="max-lsp-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="max-lsp-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'interface-switching-capability']
+
+ def _get_switching_capability(self):
+ """
+ Getter method for switching_capability, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/switching_capability (identityref)
+
+ YANG Description: Switching capability for this interface.
+ """
+ return self.__switching_capability
+
+ def _set_switching_capability(self, v, load=False):
+ """
+ Setter method for switching_capability, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/switching_capability (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_switching_capability is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_switching_capability() directly.
+
+ YANG Description: Switching capability for this interface.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """switching_capability must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__switching_capability = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_switching_capability(self):
+ self.__switching_capability = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_encoding(self):
+ """
+ Getter method for encoding, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/encoding (identityref)
+
+ YANG Description: Encoding supported by this interface.
+ """
+ return self.__encoding
+
+ def _set_encoding(self, v, load=False):
+ """
+ Setter method for encoding, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/encoding (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_encoding is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_encoding() directly.
+
+ YANG Description: Encoding supported by this interface.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """encoding must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__encoding = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_encoding(self):
+ self.__encoding = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_max_lsp_bandwidth(self):
+ """
+ Getter method for max_lsp_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth (list)
+
+ YANG Description: Maximum Label Switched Path (LSP) bandwidth at
+priorities 0-7.
+ """
+ return self.__max_lsp_bandwidth
+
+ def _set_max_lsp_bandwidth(self, v, load=False):
+ """
+ Setter method for max_lsp_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_max_lsp_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_max_lsp_bandwidth() directly.
+
+ YANG Description: Maximum Label Switched Path (LSP) bandwidth at
+priorities 0-7.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("priority",max_lsp_bandwidth.max_lsp_bandwidth, yang_name="max-lsp-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="max-lsp-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """max_lsp_bandwidth must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("priority",max_lsp_bandwidth.max_lsp_bandwidth, yang_name="max-lsp-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="max-lsp-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__max_lsp_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_max_lsp_bandwidth(self):
+ self.__max_lsp_bandwidth = YANGDynClass(base=YANGListType("priority",max_lsp_bandwidth.max_lsp_bandwidth, yang_name="max-lsp-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="max-lsp-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ switching_capability = __builtin__.property(_get_switching_capability)
+ encoding = __builtin__.property(_get_encoding)
+ max_lsp_bandwidth = __builtin__.property(_get_max_lsp_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('switching_capability', switching_capability), ('encoding', encoding), ('max_lsp_bandwidth', max_lsp_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..752eac9297da6d3ec6d48954f7a032b82abf3303
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/__init__.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+class max_lsp_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/interface-switching-capability/max-lsp-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Maximum Label Switched Path (LSP) bandwidth at
+priorities 0-7.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__priority','__te_bandwidth',)
+
+ _yang_name = 'max-lsp-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'interface-switching-capability', 'max-lsp-bandwidth']
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/priority (uint8)
+
+ YANG Description: Priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ priority = __builtin__.property(_get_priority)
+ te_bandwidth = __builtin__.property(_get_te_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('priority', priority), ('te_bandwidth', te_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4daa8700c655939dce89ef26b11e3c2d55a64fe7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/interface-switching-capability/max-lsp-bandwidth/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'interface-switching-capability', 'max-lsp-bandwidth', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn (container)
+
+ YANG Description: Maximum bandwidth attributes for OTN paths.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Maximum bandwidth attributes for OTN paths.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_bandwidth']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad8f9372d6e04795ddb3eb99f152fd3f3e3b8ff7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/__init__.py
@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/interface-switching-capability/max-lsp-bandwidth/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Maximum bandwidth attributes for OTN paths.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__max_ts_number',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__max_ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="max-ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'interface-switching-capability', 'max-lsp-bandwidth', 'te-bandwidth', 'otn']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_max_ts_number(self):
+ """
+ Getter method for max_ts_number, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/max_ts_number (uint16)
+
+ YANG Description: The maximum number of Tributary Slots (TS) that could be
+used by an ODUflex LSP.
+ """
+ return self.__max_ts_number
+
+ def _set_max_ts_number(self, v, load=False):
+ """
+ Setter method for max_ts_number, mapped from YANG variable /networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/max_ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_max_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_max_ts_number() directly.
+
+ YANG Description: The maximum number of Tributary Slots (TS) that could be
+used by an ODUflex LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="max-ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """max_ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="max-ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__max_ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_max_ts_number(self):
+ self.__max_ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="max-ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ odu_type = __builtin__.property(_get_odu_type)
+ max_ts_number = __builtin__.property(_get_max_ts_number)
+
+ __choices__ = {'technology': {'otn': ['odu_type', 'max_ts_number']}}
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('max_ts_number', max_ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..47f225a474f9b60c3d999754bcfa23c4c6f8ce39
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restriction
+class label_restrictions(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The label restrictions container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__label_restriction',)
+
+ _yang_name = 'label-restrictions'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions']
+
+ def _get_label_restriction(self):
+ """
+ Getter method for label_restriction, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction (list)
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ return self.__label_restriction
+
+ def _set_label_restriction(self, v, load=False):
+ """
+ Setter method for label_restriction, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restriction() directly.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restriction must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__label_restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restriction(self):
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ label_restriction = __builtin__.property(_get_label_restriction)
+
+
+ _pyangbind_elements = OrderedDict([('label_restriction', label_restriction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7ec9312da9070501e2186075828475e1b5fba41
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/__init__.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_start
+from . import label_end
+from . import label_step
+from . import otn_label_range
+from . import ethernet_label_range
+class label_restriction(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restriction','__index','__label_start','__label_end','__label_step','__range_bitmap','__otn_label_range','__ethernet_label_range',)
+
+ _yang_name = 'label-restriction'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction']
+
+ def _get_restriction(self):
+ """
+ Getter method for restriction, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/restriction (enumeration)
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ return self.__restriction
+
+ def _set_restriction(self, v, load=False):
+ """
+ Setter method for restriction, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/restriction (enumeration)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restriction() directly.
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restriction must be of a type compatible with enumeration""",
+ 'defined-type': "ietf-te-topology:enumeration",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)""",
+ })
+
+ self.__restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restriction(self):
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/index (uint32)
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_label_start(self):
+ """
+ Getter method for label_start, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start (container)
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ return self.__label_start
+
+ def _set_label_start(self, v, load=False):
+ """
+ Setter method for label_start, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_start is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_start() directly.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_start must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_start = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_start(self):
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_end(self):
+ """
+ Getter method for label_end, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end (container)
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ return self.__label_end
+
+ def _set_label_end(self, v, load=False):
+ """
+ Setter method for label_end, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_end is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_end() directly.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_end must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_end = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_end(self):
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_step(self):
+ """
+ Getter method for label_step, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step (container)
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ return self.__label_step
+
+ def _set_label_step(self, v, load=False):
+ """
+ Setter method for label_step, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_step() directly.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_step must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_step(self):
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_range_bitmap(self):
+ """
+ Getter method for range_bitmap, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ return self.__range_bitmap
+
+ def _set_range_bitmap(self, v, load=False):
+ """
+ Setter method for range_bitmap, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_bitmap is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_bitmap() directly.
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_bitmap must be of a type compatible with yang:hex-string""",
+ 'defined-type': "yang:hex-string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)""",
+ })
+
+ self.__range_bitmap = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_bitmap(self):
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+
+
+ def _get_otn_label_range(self):
+ """
+ Getter method for otn_label_range, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range (container)
+
+ YANG Description: Label range information for OTN.
+ """
+ return self.__otn_label_range
+
+ def _set_otn_label_range(self, v, load=False):
+ """
+ Setter method for otn_label_range, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_label_range() directly.
+
+ YANG Description: Label range information for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_label_range(self):
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_ethernet_label_range(self):
+ """
+ Getter method for ethernet_label_range, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/ethernet_label_range (container)
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ return self.__ethernet_label_range
+
+ def _set_ethernet_label_range(self, v, load=False):
+ """
+ Setter method for ethernet_label_range, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/ethernet_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ethernet_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ethernet_label_range() directly.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ethernet_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__ethernet_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ethernet_label_range(self):
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+
+ restriction = __builtin__.property(_get_restriction)
+ index = __builtin__.property(_get_index)
+ label_start = __builtin__.property(_get_label_start)
+ label_end = __builtin__.property(_get_label_end)
+ label_step = __builtin__.property(_get_label_step)
+ range_bitmap = __builtin__.property(_get_range_bitmap)
+ otn_label_range = __builtin__.property(_get_otn_label_range)
+ ethernet_label_range = __builtin__.property(_get_ethernet_label_range)
+
+
+ _pyangbind_elements = OrderedDict([('restriction', restriction), ('index', index), ('label_start', label_start), ('label_end', label_end), ('label_step', label_step), ('range_bitmap', range_bitmap), ('otn_label_range', otn_label_range), ('ethernet_label_range', ethernet_label_range), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/ethernet_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/ethernet_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..24ee2d6c9eb7e614af7c24cb021ecf3e8bbec37f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/ethernet_label_range/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ethernet_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction/ethernet-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tag_type','__priority',)
+
+ _yang_name = 'ethernet-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction', 'ethernet-label-range']
+
+ def _get_tag_type(self):
+ """
+ Getter method for tag_type, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+
+ YANG Description: VLAN tag type.
+ """
+ return self.__tag_type
+
+ def _set_tag_type(self, v, load=False):
+ """
+ Setter method for tag_type, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tag_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tag_type() directly.
+
+ YANG Description: VLAN tag type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tag_type must be of a type compatible with etht-types:eth-tag-type""",
+ 'defined-type': "etht-types:eth-tag-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)""",
+ })
+
+ self.__tag_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tag_type(self):
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+
+ YANG Description: priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+
+ tag_type = __builtin__.property(_get_tag_type)
+ priority = __builtin__.property(_get_priority)
+
+
+ _pyangbind_elements = OrderedDict([('tag_type', tag_type), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..105618cf962c111e7ad33e76558bc7b66b9fcc02
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_end(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction/label-end. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-end'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction', 'label-end']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..696280486ca37ef012a8d6922a4b02bdb97cd962
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction/label-end/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction', 'label-end', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e552cd7f5bbd878169dcea7fcad11fababa33c3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction/label-end/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction', 'label-end', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..06a33be37046c1c858cc68551313870f90938490
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_start(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction/label-start. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-start'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction', 'label-start']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d3235b9852c0ba32525cff5dedaa0c3520aca84
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction/label-start/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction', 'label-start', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a9eb242fbf4924e016e63eea71592da5037c09c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction/label-start/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction', 'label-start', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7fa272ea37185dd4b507c1e4be37a069b4bdb30
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class label_step(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction/label-step. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_step',)
+
+ _yang_name = 'label-step'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction', 'label-step']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/generic (int32)
+
+ YANG Description: Label range step.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/generic (int32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Label range step.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with int32""",
+ 'defined-type': "int32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/otn (container)
+
+ YANG Description: Label step for OTN
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label step for OTN
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_eth_step(self):
+ """
+ Getter method for eth_step, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/eth_step (uint16)
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ return self.__eth_step
+
+ def _set_eth_step(self, v, load=False):
+ """
+ Setter method for eth_step, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/eth_step (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_step() directly.
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_step must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__eth_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_step(self):
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ eth_step = __builtin__.property(_get_eth_step)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_step']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_step', eth_step), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..335aed796e0f84d0f3731e9be362cae8cc4f2965
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/otn/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction/label-step/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label step for OTN
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction', 'label-step', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c3ff7aaa3f7c1b854e39cc8354e4266ba4edcc7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/label-restrictions/label-restriction/otn-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label range information for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__range_type','__tsg','__odu_type_list','__priority',)
+
+ _yang_name = 'otn-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'label-restrictions', 'label-restriction', 'otn-label-range']
+
+ def _get_range_type(self):
+ """
+ Getter method for range_type, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ return self.__range_type
+
+ def _set_range_type(self, v, load=False):
+ """
+ Setter method for range_type, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_type() directly.
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_type must be of a type compatible with otn-label-range-type""",
+ 'defined-type': "ietf-otn-topology:otn-label-range-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)""",
+ })
+
+ self.__range_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_type(self):
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_odu_type_list(self):
+ """
+ Getter method for odu_type_list, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ return self.__odu_type_list
+
+ def _set_odu_type_list(self, v, load=False):
+ """
+ Setter method for odu_type_list, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type_list() directly.
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type_list must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__odu_type_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type_list(self):
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/link/te/information_source_entry/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+
+ range_type = __builtin__.property(_get_range_type)
+ tsg = __builtin__.property(_get_tsg)
+ odu_type_list = __builtin__.property(_get_odu_type_list)
+ priority = __builtin__.property(_get_priority)
+
+
+ _pyangbind_elements = OrderedDict([('range_type', range_type), ('tsg', tsg), ('odu_type_list', odu_type_list), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfa184bcb7f70d3487c2ef807e7a4dc7f183a019
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+class max_link_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/max-link-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Maximum bandwidth that can be seen on this link in this
+direction. Units are in bytes per second.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_bandwidth',)
+
+ _yang_name = 'max-link-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'max-link-bandwidth']
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_bandwidth = __builtin__.property(_get_te_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('te_bandwidth', te_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..26e64557cb2e40f6f9e91f44530f26bca4d556fb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/max-link-bandwidth/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'max-link-bandwidth', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff7bba04afb55d61988936b62f141b6ae3796755
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/max-link-bandwidth/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'max-link-bandwidth', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+
+ odulist = __builtin__.property(_get_odulist)
+
+
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..544fbbda76a2a0fb4dc5fc3fb7236780515fa20f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/max-link-bandwidth/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'max-link-bandwidth', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ odu_type = __builtin__.property(_get_odu_type)
+ number = __builtin__.property(_get_number)
+ ts_number = __builtin__.property(_get_ts_number)
+
+
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..08adf3f16a27f9fe208f257505f655c4f88fa2f8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+class max_resv_link_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/max-resv-link-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Maximum amount of bandwidth that can be reserved in this
+direction in this link. Units are in bytes per second.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_bandwidth',)
+
+ _yang_name = 'max-resv-link-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'max-resv-link-bandwidth']
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_bandwidth = __builtin__.property(_get_te_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('te_bandwidth', te_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf441d72d2f80a12227ce3f3eecf6275d1f79e66
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/max-resv-link-bandwidth/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'max-resv-link-bandwidth', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e7147727f540e9b913603adac8f4b86f57656f3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/max-resv-link-bandwidth/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'max-resv-link-bandwidth', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+
+ odulist = __builtin__.property(_get_odulist)
+
+
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..aff2126e7b12c1cb338d0a6fdd65143bc69d5da4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/max-resv-link-bandwidth/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'max-resv-link-bandwidth', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ odu_type = __builtin__.property(_get_odu_type)
+ number = __builtin__.property(_get_number)
+ ts_number = __builtin__.property(_get_ts_number)
+
+
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/te_nsrlgs/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/te_nsrlgs/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6704d845bcc2e4fefefa4eb79c27eb94472c2ad
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/te_nsrlgs/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class te_nsrlgs(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/te-nsrlgs. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains a list of NSRLGs (Non-Shared Risk Link Groups).
+When an abstract TE link is configured, this list specifies
+the request that underlay TE paths need to be mutually
+disjoint with other TE links in the same groups.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__id',)
+
+ _yang_name = 'te-nsrlgs'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__id = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'te-nsrlgs']
+
+ def _get_id(self):
+ """
+ Getter method for id, mapped from YANG variable /networks/network/link/te/information_source_entry/te_nsrlgs/id (uint32)
+
+ YANG Description: NSRLG ID, uniquely configured within a topology.
+ """
+ return self.__id
+
+ def _set_id(self, v, load=False):
+ """
+ Setter method for id, mapped from YANG variable /networks/network/link/te/information_source_entry/te_nsrlgs/id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_id() directly.
+
+ YANG Description: NSRLG ID, uniquely configured within a topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_id(self):
+ self.__id = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+ id = __builtin__.property(_get_id)
+
+
+ _pyangbind_elements = OrderedDict([('id', id), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/te_srlgs/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/te_srlgs/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c51afe6b0c912238c170753f4f2979b9a08851c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/te_srlgs/__init__.py
@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class te_srlgs(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/te-srlgs. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains a list of SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__value',)
+
+ _yang_name = 'te-srlgs'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__value = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:srlg', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'te-srlgs']
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/link/te/information_source_entry/te_srlgs/value (te-types:srlg)
+
+ YANG Description: SRLG value.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/link/te/information_source_entry/te_srlgs/value (te-types:srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: SRLG value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:srlg', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with te-types:srlg""",
+ 'defined-type': "te-types:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:srlg', is_config=False)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:srlg', is_config=False)
+
+ value = __builtin__.property(_get_value)
+
+
+ _pyangbind_elements = OrderedDict([('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2151706363bc91a46c2a2126406a55309598f01
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/__init__.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+class unreserved_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/unreserved-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unreserved bandwidth for priority levels 0-7. Units are in
+bytes per second.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__priority','__te_bandwidth',)
+
+ _yang_name = 'unreserved-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'unreserved-bandwidth']
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/priority (uint8)
+
+ YANG Description: Priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ priority = __builtin__.property(_get_priority)
+ te_bandwidth = __builtin__.property(_get_te_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('priority', priority), ('te_bandwidth', te_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c786d1941f8b391e743a8422f6d23a13913c2f88
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/unreserved-bandwidth/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'unreserved-bandwidth', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e3a01bcafc387f6a74c8904eb2f8582932998a1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/unreserved-bandwidth/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'unreserved-bandwidth', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+
+ odulist = __builtin__.property(_get_odulist)
+
+
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0e9a8f1d89ec9dac1dd28f9aef4431b271883c0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-entry/unreserved-bandwidth/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-entry', 'unreserved-bandwidth', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ odu_type = __builtin__.property(_get_odu_type)
+ number = __builtin__.property(_get_number)
+ ts_number = __builtin__.property(_get_ts_number)
+
+
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_state/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_state/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4646d00267a1a8740cddfd61eb2f6f55e6d241bd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_state/__init__.py
@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import topology
+class information_source_state(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-state. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__credibility_preference','__logical_network_element','__network_instance','__topology',)
+
+ _yang_name = 'information-source-state'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__credibility_preference = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+ self.__logical_network_element = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__network_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__topology = YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-state']
+
+ def _get_credibility_preference(self):
+ """
+ Getter method for credibility_preference, mapped from YANG variable /networks/network/link/te/information_source_state/credibility_preference (uint16)
+
+ YANG Description: The preference value for calculating the Traffic
+Engineering database credibility value used for
+tie-break selection between different information-source
+values. A higher value is preferable.
+ """
+ return self.__credibility_preference
+
+ def _set_credibility_preference(self, v, load=False):
+ """
+ Setter method for credibility_preference, mapped from YANG variable /networks/network/link/te/information_source_state/credibility_preference (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_credibility_preference is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_credibility_preference() directly.
+
+ YANG Description: The preference value for calculating the Traffic
+Engineering database credibility value used for
+tie-break selection between different information-source
+values. A higher value is preferable.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """credibility_preference must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__credibility_preference = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_credibility_preference(self):
+ self.__credibility_preference = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+
+
+ def _get_logical_network_element(self):
+ """
+ Getter method for logical_network_element, mapped from YANG variable /networks/network/link/te/information_source_state/logical_network_element (string)
+
+ YANG Description: When applicable, this is the name of a logical network
+element from which the information is learned.
+ """
+ return self.__logical_network_element
+
+ def _set_logical_network_element(self, v, load=False):
+ """
+ Setter method for logical_network_element, mapped from YANG variable /networks/network/link/te/information_source_state/logical_network_element (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_logical_network_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_logical_network_element() directly.
+
+ YANG Description: When applicable, this is the name of a logical network
+element from which the information is learned.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """logical_network_element must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__logical_network_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_logical_network_element(self):
+ self.__logical_network_element = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_network_instance(self):
+ """
+ Getter method for network_instance, mapped from YANG variable /networks/network/link/te/information_source_state/network_instance (string)
+
+ YANG Description: When applicable, this is the name of a network instance
+from which the information is learned.
+ """
+ return self.__network_instance
+
+ def _set_network_instance(self, v, load=False):
+ """
+ Setter method for network_instance, mapped from YANG variable /networks/network/link/te/information_source_state/network_instance (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_instance is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_instance() directly.
+
+ YANG Description: When applicable, this is the name of a network instance
+from which the information is learned.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_instance must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__network_instance = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_instance(self):
+ self.__network_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_topology(self):
+ """
+ Getter method for topology, mapped from YANG variable /networks/network/link/te/information_source_state/topology (container)
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ return self.__topology
+
+ def _set_topology(self, v, load=False):
+ """
+ Setter method for topology, mapped from YANG variable /networks/network/link/te/information_source_state/topology (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_topology is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_topology() directly.
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """topology must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__topology = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_topology(self):
+ self.__topology = YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ credibility_preference = __builtin__.property(_get_credibility_preference)
+ logical_network_element = __builtin__.property(_get_logical_network_element)
+ network_instance = __builtin__.property(_get_network_instance)
+ topology = __builtin__.property(_get_topology)
+
+
+ _pyangbind_elements = OrderedDict([('credibility_preference', credibility_preference), ('logical_network_element', logical_network_element), ('network_instance', network_instance), ('topology', topology), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_state/topology/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_state/topology/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a22bed59f6d55f3d9c34838f790317f68e64361
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/information_source_state/topology/__init__.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/information-source-state/topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_ref','__network_ref',)
+
+ _yang_name = 'topology'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'information-source-state', 'topology']
+
+ def _get_link_ref(self):
+ """
+ Getter method for link_ref, mapped from YANG variable /networks/network/link/te/information_source_state/topology/link_ref (leafref)
+
+ YANG Description: A type for an absolute reference to a link instance.
+(This type should not be used for relative references.
+In such a case, a relative path should be used instead.)
+ """
+ return self.__link_ref
+
+ def _set_link_ref(self, v, load=False):
+ """
+ Setter method for link_ref, mapped from YANG variable /networks/network/link/te/information_source_state/topology/link_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_ref() directly.
+
+ YANG Description: A type for an absolute reference to a link instance.
+(This type should not be used for relative references.
+In such a case, a relative path should be used instead.)
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__link_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_ref(self):
+ self.__link_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/link/te/information_source_state/topology/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/link/te/information_source_state/topology/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+ link_ref = __builtin__.property(_get_link_ref)
+ network_ref = __builtin__.property(_get_network_ref)
+
+
+ _pyangbind_elements = OrderedDict([('link_ref', link_ref), ('network_ref', network_ref), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/recovery/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/recovery/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..441cf6d42f12b1cb923eb18703988060e533fb5f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/recovery/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class recovery(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/recovery. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Status of the recovery process.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restoration_status','__protection_status',)
+
+ _yang_name = 'recovery'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restoration_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'normal': {}, 'recovery-started': {}, 'recovery-succeeded': {}, 'recovery-failed': {}, 'reversion-started': {}, 'reversion-succeeded': {}, 'reversion-failed': {}, 'recovery-unavailable': {}, 'recovery-admin': {}, 'wait-to-restore': {}},), is_leaf=True, yang_name="restoration-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-recovery-status', is_config=False)
+ self.__protection_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'normal': {}, 'recovery-started': {}, 'recovery-succeeded': {}, 'recovery-failed': {}, 'reversion-started': {}, 'reversion-succeeded': {}, 'reversion-failed': {}, 'recovery-unavailable': {}, 'recovery-admin': {}, 'wait-to-restore': {}},), is_leaf=True, yang_name="protection-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-recovery-status', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'recovery']
+
+ def _get_restoration_status(self):
+ """
+ Getter method for restoration_status, mapped from YANG variable /networks/network/link/te/recovery/restoration_status (te-types:te-recovery-status)
+
+ YANG Description: Restoration status.
+ """
+ return self.__restoration_status
+
+ def _set_restoration_status(self, v, load=False):
+ """
+ Setter method for restoration_status, mapped from YANG variable /networks/network/link/te/recovery/restoration_status (te-types:te-recovery-status)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restoration_status is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restoration_status() directly.
+
+ YANG Description: Restoration status.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'normal': {}, 'recovery-started': {}, 'recovery-succeeded': {}, 'recovery-failed': {}, 'reversion-started': {}, 'reversion-succeeded': {}, 'reversion-failed': {}, 'recovery-unavailable': {}, 'recovery-admin': {}, 'wait-to-restore': {}},), is_leaf=True, yang_name="restoration-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-recovery-status', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restoration_status must be of a type compatible with te-types:te-recovery-status""",
+ 'defined-type': "te-types:te-recovery-status",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'normal': {}, 'recovery-started': {}, 'recovery-succeeded': {}, 'recovery-failed': {}, 'reversion-started': {}, 'reversion-succeeded': {}, 'reversion-failed': {}, 'recovery-unavailable': {}, 'recovery-admin': {}, 'wait-to-restore': {}},), is_leaf=True, yang_name="restoration-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-recovery-status', is_config=False)""",
+ })
+
+ self.__restoration_status = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restoration_status(self):
+ self.__restoration_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'normal': {}, 'recovery-started': {}, 'recovery-succeeded': {}, 'recovery-failed': {}, 'reversion-started': {}, 'reversion-succeeded': {}, 'reversion-failed': {}, 'recovery-unavailable': {}, 'recovery-admin': {}, 'wait-to-restore': {}},), is_leaf=True, yang_name="restoration-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-recovery-status', is_config=False)
+
+
+ def _get_protection_status(self):
+ """
+ Getter method for protection_status, mapped from YANG variable /networks/network/link/te/recovery/protection_status (te-types:te-recovery-status)
+
+ YANG Description: Protection status.
+ """
+ return self.__protection_status
+
+ def _set_protection_status(self, v, load=False):
+ """
+ Setter method for protection_status, mapped from YANG variable /networks/network/link/te/recovery/protection_status (te-types:te-recovery-status)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_protection_status is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_protection_status() directly.
+
+ YANG Description: Protection status.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'normal': {}, 'recovery-started': {}, 'recovery-succeeded': {}, 'recovery-failed': {}, 'reversion-started': {}, 'reversion-succeeded': {}, 'reversion-failed': {}, 'recovery-unavailable': {}, 'recovery-admin': {}, 'wait-to-restore': {}},), is_leaf=True, yang_name="protection-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-recovery-status', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """protection_status must be of a type compatible with te-types:te-recovery-status""",
+ 'defined-type': "te-types:te-recovery-status",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'normal': {}, 'recovery-started': {}, 'recovery-succeeded': {}, 'recovery-failed': {}, 'reversion-started': {}, 'reversion-succeeded': {}, 'reversion-failed': {}, 'recovery-unavailable': {}, 'recovery-admin': {}, 'wait-to-restore': {}},), is_leaf=True, yang_name="protection-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-recovery-status', is_config=False)""",
+ })
+
+ self.__protection_status = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_protection_status(self):
+ self.__protection_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'normal': {}, 'recovery-started': {}, 'recovery-succeeded': {}, 'recovery-failed': {}, 'reversion-started': {}, 'reversion-succeeded': {}, 'reversion-failed': {}, 'recovery-unavailable': {}, 'recovery-admin': {}, 'wait-to-restore': {}},), is_leaf=True, yang_name="protection-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-recovery-status', is_config=False)
+
+ restoration_status = __builtin__.property(_get_restoration_status)
+ protection_status = __builtin__.property(_get_protection_status)
+
+
+ _pyangbind_elements = OrderedDict([('restoration_status', restoration_status), ('protection_status', protection_status), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/statistics/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/statistics/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbfbda90fca5f685855f866bba04ab806cb12b35
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/statistics/__init__.py
@@ -0,0 +1,810 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class statistics(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/statistics. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Statistics data.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__discontinuity_time','__disables','__enables','__maintenance_clears','__maintenance_sets','__modifies','__downs','__ups','__fault_clears','__fault_detects','__protection_switches','__protection_reverts','__restoration_failures','__restoration_starts','__restoration_successes','__restoration_reversion_failures','__restoration_reversion_starts','__restoration_reversion_successes',)
+
+ _yang_name = 'statistics'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__discontinuity_time = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[\\+\\-]\\d{2}:\\d{2})'}), is_leaf=True, yang_name="discontinuity-time", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:date-and-time', is_config=False)
+ self.__disables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__enables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__maintenance_clears = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__maintenance_sets = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-sets", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__modifies = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__downs = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="downs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__ups = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="ups", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__fault_clears = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="fault-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__fault_detects = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="fault-detects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__protection_switches = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="protection-switches", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__protection_reverts = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="protection-reverts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__restoration_failures = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-failures", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__restoration_starts = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-starts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__restoration_successes = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-successes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__restoration_reversion_failures = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-failures", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__restoration_reversion_starts = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-starts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__restoration_reversion_successes = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-successes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'statistics']
+
+ def _get_discontinuity_time(self):
+ """
+ Getter method for discontinuity_time, mapped from YANG variable /networks/network/link/te/statistics/discontinuity_time (yang:date-and-time)
+
+ YANG Description: The time of the most recent occasion at which any one or
+more of this interface's counters suffered a
+discontinuity. If no such discontinuities have occurred
+since the last re-initialization of the local management
+subsystem, then this node contains the time the local
+management subsystem re-initialized itself.
+ """
+ return self.__discontinuity_time
+
+ def _set_discontinuity_time(self, v, load=False):
+ """
+ Setter method for discontinuity_time, mapped from YANG variable /networks/network/link/te/statistics/discontinuity_time (yang:date-and-time)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_discontinuity_time is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_discontinuity_time() directly.
+
+ YANG Description: The time of the most recent occasion at which any one or
+more of this interface's counters suffered a
+discontinuity. If no such discontinuities have occurred
+since the last re-initialization of the local management
+subsystem, then this node contains the time the local
+management subsystem re-initialized itself.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[\\+\\-]\\d{2}:\\d{2})'}), is_leaf=True, yang_name="discontinuity-time", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:date-and-time', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """discontinuity_time must be of a type compatible with yang:date-and-time""",
+ 'defined-type': "yang:date-and-time",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[\\+\\-]\\d{2}:\\d{2})'}), is_leaf=True, yang_name="discontinuity-time", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:date-and-time', is_config=False)""",
+ })
+
+ self.__discontinuity_time = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_discontinuity_time(self):
+ self.__discontinuity_time = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[\\+\\-]\\d{2}:\\d{2})'}), is_leaf=True, yang_name="discontinuity-time", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:date-and-time', is_config=False)
+
+
+ def _get_disables(self):
+ """
+ Getter method for disables, mapped from YANG variable /networks/network/link/te/statistics/disables (yang:counter32)
+
+ YANG Description: Number of times that a link was disabled.
+ """
+ return self.__disables
+
+ def _set_disables(self, v, load=False):
+ """
+ Setter method for disables, mapped from YANG variable /networks/network/link/te/statistics/disables (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_disables is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_disables() directly.
+
+ YANG Description: Number of times that a link was disabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """disables must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__disables = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_disables(self):
+ self.__disables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_enables(self):
+ """
+ Getter method for enables, mapped from YANG variable /networks/network/link/te/statistics/enables (yang:counter32)
+
+ YANG Description: Number of times that a link was enabled.
+ """
+ return self.__enables
+
+ def _set_enables(self, v, load=False):
+ """
+ Setter method for enables, mapped from YANG variable /networks/network/link/te/statistics/enables (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_enables is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_enables() directly.
+
+ YANG Description: Number of times that a link was enabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """enables must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__enables = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_enables(self):
+ self.__enables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_maintenance_clears(self):
+ """
+ Getter method for maintenance_clears, mapped from YANG variable /networks/network/link/te/statistics/maintenance_clears (yang:counter32)
+
+ YANG Description: Number of times that a link was taken out of maintenance.
+ """
+ return self.__maintenance_clears
+
+ def _set_maintenance_clears(self, v, load=False):
+ """
+ Setter method for maintenance_clears, mapped from YANG variable /networks/network/link/te/statistics/maintenance_clears (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_maintenance_clears is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_maintenance_clears() directly.
+
+ YANG Description: Number of times that a link was taken out of maintenance.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """maintenance_clears must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__maintenance_clears = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_maintenance_clears(self):
+ self.__maintenance_clears = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_maintenance_sets(self):
+ """
+ Getter method for maintenance_sets, mapped from YANG variable /networks/network/link/te/statistics/maintenance_sets (yang:counter32)
+
+ YANG Description: Number of times that a link was put in maintenance.
+ """
+ return self.__maintenance_sets
+
+ def _set_maintenance_sets(self, v, load=False):
+ """
+ Setter method for maintenance_sets, mapped from YANG variable /networks/network/link/te/statistics/maintenance_sets (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_maintenance_sets is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_maintenance_sets() directly.
+
+ YANG Description: Number of times that a link was put in maintenance.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-sets", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """maintenance_sets must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-sets", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__maintenance_sets = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_maintenance_sets(self):
+ self.__maintenance_sets = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-sets", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_modifies(self):
+ """
+ Getter method for modifies, mapped from YANG variable /networks/network/link/te/statistics/modifies (yang:counter32)
+
+ YANG Description: Number of times that a link was modified.
+ """
+ return self.__modifies
+
+ def _set_modifies(self, v, load=False):
+ """
+ Setter method for modifies, mapped from YANG variable /networks/network/link/te/statistics/modifies (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_modifies is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_modifies() directly.
+
+ YANG Description: Number of times that a link was modified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """modifies must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__modifies = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_modifies(self):
+ self.__modifies = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_downs(self):
+ """
+ Getter method for downs, mapped from YANG variable /networks/network/link/te/statistics/downs (yang:counter32)
+
+ YANG Description: Number of times that a link was set to an operational state
+of 'down'.
+ """
+ return self.__downs
+
+ def _set_downs(self, v, load=False):
+ """
+ Setter method for downs, mapped from YANG variable /networks/network/link/te/statistics/downs (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_downs is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_downs() directly.
+
+ YANG Description: Number of times that a link was set to an operational state
+of 'down'.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="downs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """downs must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="downs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__downs = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_downs(self):
+ self.__downs = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="downs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_ups(self):
+ """
+ Getter method for ups, mapped from YANG variable /networks/network/link/te/statistics/ups (yang:counter32)
+
+ YANG Description: Number of times that a link was set to an operational state
+of 'up'.
+ """
+ return self.__ups
+
+ def _set_ups(self, v, load=False):
+ """
+ Setter method for ups, mapped from YANG variable /networks/network/link/te/statistics/ups (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ups is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ups() directly.
+
+ YANG Description: Number of times that a link was set to an operational state
+of 'up'.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="ups", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ups must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="ups", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__ups = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ups(self):
+ self.__ups = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="ups", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_fault_clears(self):
+ """
+ Getter method for fault_clears, mapped from YANG variable /networks/network/link/te/statistics/fault_clears (yang:counter32)
+
+ YANG Description: Number of times that a link experienced a fault-clear
+event.
+ """
+ return self.__fault_clears
+
+ def _set_fault_clears(self, v, load=False):
+ """
+ Setter method for fault_clears, mapped from YANG variable /networks/network/link/te/statistics/fault_clears (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_fault_clears is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_fault_clears() directly.
+
+ YANG Description: Number of times that a link experienced a fault-clear
+event.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="fault-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """fault_clears must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="fault-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__fault_clears = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_fault_clears(self):
+ self.__fault_clears = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="fault-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_fault_detects(self):
+ """
+ Getter method for fault_detects, mapped from YANG variable /networks/network/link/te/statistics/fault_detects (yang:counter32)
+
+ YANG Description: Number of times that a link experienced fault detection.
+ """
+ return self.__fault_detects
+
+ def _set_fault_detects(self, v, load=False):
+ """
+ Setter method for fault_detects, mapped from YANG variable /networks/network/link/te/statistics/fault_detects (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_fault_detects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_fault_detects() directly.
+
+ YANG Description: Number of times that a link experienced fault detection.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="fault-detects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """fault_detects must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="fault-detects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__fault_detects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_fault_detects(self):
+ self.__fault_detects = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="fault-detects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_protection_switches(self):
+ """
+ Getter method for protection_switches, mapped from YANG variable /networks/network/link/te/statistics/protection_switches (yang:counter32)
+
+ YANG Description: Number of times that a link experienced protection
+switchover.
+ """
+ return self.__protection_switches
+
+ def _set_protection_switches(self, v, load=False):
+ """
+ Setter method for protection_switches, mapped from YANG variable /networks/network/link/te/statistics/protection_switches (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_protection_switches is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_protection_switches() directly.
+
+ YANG Description: Number of times that a link experienced protection
+switchover.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="protection-switches", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """protection_switches must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="protection-switches", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__protection_switches = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_protection_switches(self):
+ self.__protection_switches = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="protection-switches", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_protection_reverts(self):
+ """
+ Getter method for protection_reverts, mapped from YANG variable /networks/network/link/te/statistics/protection_reverts (yang:counter32)
+
+ YANG Description: Number of times that a link experienced protection
+reversion.
+ """
+ return self.__protection_reverts
+
+ def _set_protection_reverts(self, v, load=False):
+ """
+ Setter method for protection_reverts, mapped from YANG variable /networks/network/link/te/statistics/protection_reverts (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_protection_reverts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_protection_reverts() directly.
+
+ YANG Description: Number of times that a link experienced protection
+reversion.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="protection-reverts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """protection_reverts must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="protection-reverts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__protection_reverts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_protection_reverts(self):
+ self.__protection_reverts = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="protection-reverts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_restoration_failures(self):
+ """
+ Getter method for restoration_failures, mapped from YANG variable /networks/network/link/te/statistics/restoration_failures (yang:counter32)
+
+ YANG Description: Number of times that a link experienced restoration
+failure.
+ """
+ return self.__restoration_failures
+
+ def _set_restoration_failures(self, v, load=False):
+ """
+ Setter method for restoration_failures, mapped from YANG variable /networks/network/link/te/statistics/restoration_failures (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restoration_failures is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restoration_failures() directly.
+
+ YANG Description: Number of times that a link experienced restoration
+failure.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-failures", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restoration_failures must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-failures", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__restoration_failures = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restoration_failures(self):
+ self.__restoration_failures = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-failures", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_restoration_starts(self):
+ """
+ Getter method for restoration_starts, mapped from YANG variable /networks/network/link/te/statistics/restoration_starts (yang:counter32)
+
+ YANG Description: Number of times that a link experienced restoration
+start.
+ """
+ return self.__restoration_starts
+
+ def _set_restoration_starts(self, v, load=False):
+ """
+ Setter method for restoration_starts, mapped from YANG variable /networks/network/link/te/statistics/restoration_starts (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restoration_starts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restoration_starts() directly.
+
+ YANG Description: Number of times that a link experienced restoration
+start.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-starts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restoration_starts must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-starts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__restoration_starts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restoration_starts(self):
+ self.__restoration_starts = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-starts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_restoration_successes(self):
+ """
+ Getter method for restoration_successes, mapped from YANG variable /networks/network/link/te/statistics/restoration_successes (yang:counter32)
+
+ YANG Description: Number of times that a link experienced restoration
+success.
+ """
+ return self.__restoration_successes
+
+ def _set_restoration_successes(self, v, load=False):
+ """
+ Setter method for restoration_successes, mapped from YANG variable /networks/network/link/te/statistics/restoration_successes (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restoration_successes is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restoration_successes() directly.
+
+ YANG Description: Number of times that a link experienced restoration
+success.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-successes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restoration_successes must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-successes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__restoration_successes = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restoration_successes(self):
+ self.__restoration_successes = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-successes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_restoration_reversion_failures(self):
+ """
+ Getter method for restoration_reversion_failures, mapped from YANG variable /networks/network/link/te/statistics/restoration_reversion_failures (yang:counter32)
+
+ YANG Description: Number of times that a link experienced restoration
+reversion failure.
+ """
+ return self.__restoration_reversion_failures
+
+ def _set_restoration_reversion_failures(self, v, load=False):
+ """
+ Setter method for restoration_reversion_failures, mapped from YANG variable /networks/network/link/te/statistics/restoration_reversion_failures (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restoration_reversion_failures is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restoration_reversion_failures() directly.
+
+ YANG Description: Number of times that a link experienced restoration
+reversion failure.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-failures", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restoration_reversion_failures must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-failures", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__restoration_reversion_failures = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restoration_reversion_failures(self):
+ self.__restoration_reversion_failures = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-failures", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_restoration_reversion_starts(self):
+ """
+ Getter method for restoration_reversion_starts, mapped from YANG variable /networks/network/link/te/statistics/restoration_reversion_starts (yang:counter32)
+
+ YANG Description: Number of times that a link experienced restoration
+reversion start.
+ """
+ return self.__restoration_reversion_starts
+
+ def _set_restoration_reversion_starts(self, v, load=False):
+ """
+ Setter method for restoration_reversion_starts, mapped from YANG variable /networks/network/link/te/statistics/restoration_reversion_starts (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restoration_reversion_starts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restoration_reversion_starts() directly.
+
+ YANG Description: Number of times that a link experienced restoration
+reversion start.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-starts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restoration_reversion_starts must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-starts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__restoration_reversion_starts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restoration_reversion_starts(self):
+ self.__restoration_reversion_starts = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-starts", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_restoration_reversion_successes(self):
+ """
+ Getter method for restoration_reversion_successes, mapped from YANG variable /networks/network/link/te/statistics/restoration_reversion_successes (yang:counter32)
+
+ YANG Description: Number of times that a link experienced restoration
+reversion success.
+ """
+ return self.__restoration_reversion_successes
+
+ def _set_restoration_reversion_successes(self, v, load=False):
+ """
+ Setter method for restoration_reversion_successes, mapped from YANG variable /networks/network/link/te/statistics/restoration_reversion_successes (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restoration_reversion_successes is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restoration_reversion_successes() directly.
+
+ YANG Description: Number of times that a link experienced restoration
+reversion success.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-successes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restoration_reversion_successes must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-successes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__restoration_reversion_successes = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restoration_reversion_successes(self):
+ self.__restoration_reversion_successes = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="restoration-reversion-successes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+ discontinuity_time = __builtin__.property(_get_discontinuity_time)
+ disables = __builtin__.property(_get_disables)
+ enables = __builtin__.property(_get_enables)
+ maintenance_clears = __builtin__.property(_get_maintenance_clears)
+ maintenance_sets = __builtin__.property(_get_maintenance_sets)
+ modifies = __builtin__.property(_get_modifies)
+ downs = __builtin__.property(_get_downs)
+ ups = __builtin__.property(_get_ups)
+ fault_clears = __builtin__.property(_get_fault_clears)
+ fault_detects = __builtin__.property(_get_fault_detects)
+ protection_switches = __builtin__.property(_get_protection_switches)
+ protection_reverts = __builtin__.property(_get_protection_reverts)
+ restoration_failures = __builtin__.property(_get_restoration_failures)
+ restoration_starts = __builtin__.property(_get_restoration_starts)
+ restoration_successes = __builtin__.property(_get_restoration_successes)
+ restoration_reversion_failures = __builtin__.property(_get_restoration_reversion_failures)
+ restoration_reversion_starts = __builtin__.property(_get_restoration_reversion_starts)
+ restoration_reversion_successes = __builtin__.property(_get_restoration_reversion_successes)
+
+
+ _pyangbind_elements = OrderedDict([('discontinuity_time', discontinuity_time), ('disables', disables), ('enables', enables), ('maintenance_clears', maintenance_clears), ('maintenance_sets', maintenance_sets), ('modifies', modifies), ('downs', downs), ('ups', ups), ('fault_clears', fault_clears), ('fault_detects', fault_detects), ('protection_switches', protection_switches), ('protection_reverts', protection_reverts), ('restoration_failures', restoration_failures), ('restoration_starts', restoration_starts), ('restoration_successes', restoration_successes), ('restoration_reversion_failures', restoration_reversion_failures), ('restoration_reversion_starts', restoration_reversion_starts), ('restoration_reversion_successes', restoration_reversion_successes), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f83e385c43cf4ee2c24fa6bde7b528d15df5ae2c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/__init__.py
@@ -0,0 +1,938 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import external_domain
+from . import underlay
+from . import interface_switching_capability
+from . import label_restrictions
+from . import max_link_bandwidth
+from . import max_resv_link_bandwidth
+from . import unreserved_bandwidth
+from . import te_srlgs
+from . import te_nsrlgs
+from . import otn_link
+from . import client_svc
+class te_link_attributes(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Link attributes in a TE topology.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__access_type','__external_domain','__is_abstract','__name','__underlay','__admin_status','__link_index','__administrative_group','__interface_switching_capability','__label_restrictions','__link_protection_type','__max_link_bandwidth','__max_resv_link_bandwidth','__unreserved_bandwidth','__te_default_metric','__te_delay_metric','__te_igp_metric','__te_srlgs','__te_nsrlgs','__otn_link','__client_svc',)
+
+ _yang_name = 'te-link-attributes'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__access_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'point-to-point': {}, 'multi-access': {}},), is_leaf=True, yang_name="access-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-link-access-type', is_config=True)
+ self.__external_domain = YANGDynClass(base=external_domain.external_domain, is_container='container', yang_name="external-domain", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__is_abstract = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=True)
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__admin_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)
+ self.__link_index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="link-index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+ self.__administrative_group = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], is_leaf=True, yang_name="administrative-group", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:admin-groups', is_config=True)
+ self.__interface_switching_capability = YANGDynClass(base=YANGListType("switching_capability encoding",interface_switching_capability.interface_switching_capability, yang_name="interface-switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="interface-switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__link_protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="link-protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__max_link_bandwidth = YANGDynClass(base=max_link_bandwidth.max_link_bandwidth, is_container='container', yang_name="max-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__max_resv_link_bandwidth = YANGDynClass(base=max_resv_link_bandwidth.max_resv_link_bandwidth, is_container='container', yang_name="max-resv-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unreserved_bandwidth = YANGDynClass(base=YANGListType("priority",unreserved_bandwidth.unreserved_bandwidth, yang_name="unreserved-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="unreserved-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ self.__te_default_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-default-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__te_delay_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-delay-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__te_igp_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-igp-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__te_srlgs = YANGDynClass(base=te_srlgs.te_srlgs, is_container='container', yang_name="te-srlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__te_nsrlgs = YANGDynClass(base=te_nsrlgs.te_nsrlgs, is_container='container', yang_name="te-nsrlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__otn_link = YANGDynClass(base=otn_link.otn_link, is_container='container', yang_name="otn-link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__client_svc = YANGDynClass(base=client_svc.client_svc, is_container='container', yang_name="client-svc", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes']
+
+ def _get_access_type(self):
+ """
+ Getter method for access_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/access_type (te-types:te-link-access-type)
+
+ YANG Description: Link access type, which can be point-to-point or
+multi-access.
+ """
+ return self.__access_type
+
+ def _set_access_type(self, v, load=False):
+ """
+ Setter method for access_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/access_type (te-types:te-link-access-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_access_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_access_type() directly.
+
+ YANG Description: Link access type, which can be point-to-point or
+multi-access.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'point-to-point': {}, 'multi-access': {}},), is_leaf=True, yang_name="access-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-link-access-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """access_type must be of a type compatible with te-types:te-link-access-type""",
+ 'defined-type': "te-types:te-link-access-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'point-to-point': {}, 'multi-access': {}},), is_leaf=True, yang_name="access-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-link-access-type', is_config=True)""",
+ })
+
+ self.__access_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_access_type(self):
+ self.__access_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'point-to-point': {}, 'multi-access': {}},), is_leaf=True, yang_name="access-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-link-access-type', is_config=True)
+
+
+ def _get_external_domain(self):
+ """
+ Getter method for external_domain, mapped from YANG variable /networks/network/link/te/te_link_attributes/external_domain (container)
+
+ YANG Description: For an inter-domain link, specifies the attributes of
+the remote end of the link, to facilitate the signaling at
+the local end.
+ """
+ return self.__external_domain
+
+ def _set_external_domain(self, v, load=False):
+ """
+ Setter method for external_domain, mapped from YANG variable /networks/network/link/te/te_link_attributes/external_domain (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_external_domain is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_external_domain() directly.
+
+ YANG Description: For an inter-domain link, specifies the attributes of
+the remote end of the link, to facilitate the signaling at
+the local end.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=external_domain.external_domain, is_container='container', yang_name="external-domain", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """external_domain must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=external_domain.external_domain, is_container='container', yang_name="external-domain", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__external_domain = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_external_domain(self):
+ self.__external_domain = YANGDynClass(base=external_domain.external_domain, is_container='container', yang_name="external-domain", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_is_abstract(self):
+ """
+ Getter method for is_abstract, mapped from YANG variable /networks/network/link/te/te_link_attributes/is_abstract (empty)
+
+ YANG Description: Present if the link is abstract.
+ """
+ return self.__is_abstract
+
+ def _set_is_abstract(self, v, load=False):
+ """
+ Setter method for is_abstract, mapped from YANG variable /networks/network/link/te/te_link_attributes/is_abstract (empty)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_abstract is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_abstract() directly.
+
+ YANG Description: Present if the link is abstract.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_abstract must be of a type compatible with empty""",
+ 'defined-type': "empty",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=True)""",
+ })
+
+ self.__is_abstract = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_abstract(self):
+ self.__is_abstract = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=True)
+
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/link/te/te_link_attributes/name (string)
+
+ YANG Description: Link name.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/link/te/te_link_attributes/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Link name.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+
+ def _get_underlay(self):
+ """
+ Getter method for underlay, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay (container)
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ return self.__underlay
+
+ def _set_underlay(self, v, load=False):
+ """
+ Setter method for underlay, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_underlay is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_underlay() directly.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """underlay must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__underlay = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_underlay(self):
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_admin_status(self):
+ """
+ Getter method for admin_status, mapped from YANG variable /networks/network/link/te/te_link_attributes/admin_status (te-types:te-admin-status)
+
+ YANG Description: The administrative state of the link.
+ """
+ return self.__admin_status
+
+ def _set_admin_status(self, v, load=False):
+ """
+ Setter method for admin_status, mapped from YANG variable /networks/network/link/te/te_link_attributes/admin_status (te-types:te-admin-status)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_admin_status is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_admin_status() directly.
+
+ YANG Description: The administrative state of the link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """admin_status must be of a type compatible with te-types:te-admin-status""",
+ 'defined-type': "te-types:te-admin-status",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)""",
+ })
+
+ self.__admin_status = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_admin_status(self):
+ self.__admin_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)
+
+
+ def _get_link_index(self):
+ """
+ Getter method for link_index, mapped from YANG variable /networks/network/link/te/te_link_attributes/link_index (uint64)
+
+ YANG Description: The link identifier. If OSPF is used, this object
+represents an ospfLsdbID. If IS-IS is used, this object
+represents an isisLSPID. If a locally configured link is
+used, this object represents a unique value, which is
+locally defined in a router.
+ """
+ return self.__link_index
+
+ def _set_link_index(self, v, load=False):
+ """
+ Setter method for link_index, mapped from YANG variable /networks/network/link/te/te_link_attributes/link_index (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_index() directly.
+
+ YANG Description: The link identifier. If OSPF is used, this object
+represents an ospfLsdbID. If IS-IS is used, this object
+represents an isisLSPID. If a locally configured link is
+used, this object represents a unique value, which is
+locally defined in a router.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="link-index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_index must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="link-index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__link_index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_index(self):
+ self.__link_index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="link-index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+
+
+ def _get_administrative_group(self):
+ """
+ Getter method for administrative_group, mapped from YANG variable /networks/network/link/te/te_link_attributes/administrative_group (te-types:admin-groups)
+
+ YANG Description: Administrative group or color of the link.
+This attribute covers both administrative groups (defined
+in RFCs 3630 and 5305) and Extended Administrative Groups
+(defined in RFC 7308).
+ """
+ return self.__administrative_group
+
+ def _set_administrative_group(self, v, load=False):
+ """
+ Setter method for administrative_group, mapped from YANG variable /networks/network/link/te/te_link_attributes/administrative_group (te-types:admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_administrative_group is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_administrative_group() directly.
+
+ YANG Description: Administrative group or color of the link.
+This attribute covers both administrative groups (defined
+in RFCs 3630 and 5305) and Extended Administrative Groups
+(defined in RFC 7308).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], is_leaf=True, yang_name="administrative-group", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:admin-groups', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """administrative_group must be of a type compatible with te-types:admin-groups""",
+ 'defined-type': "te-types:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], is_leaf=True, yang_name="administrative-group", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:admin-groups', is_config=True)""",
+ })
+
+ self.__administrative_group = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_administrative_group(self):
+ self.__administrative_group = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], is_leaf=True, yang_name="administrative-group", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:admin-groups', is_config=True)
+
+
+ def _get_interface_switching_capability(self):
+ """
+ Getter method for interface_switching_capability, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability (list)
+
+ YANG Description: List of ISCDs for this link.
+ """
+ return self.__interface_switching_capability
+
+ def _set_interface_switching_capability(self, v, load=False):
+ """
+ Setter method for interface_switching_capability, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_interface_switching_capability is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_interface_switching_capability() directly.
+
+ YANG Description: List of ISCDs for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("switching_capability encoding",interface_switching_capability.interface_switching_capability, yang_name="interface-switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="interface-switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """interface_switching_capability must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("switching_capability encoding",interface_switching_capability.interface_switching_capability, yang_name="interface-switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="interface-switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__interface_switching_capability = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_interface_switching_capability(self):
+ self.__interface_switching_capability = YANGDynClass(base=YANGListType("switching_capability encoding",interface_switching_capability.interface_switching_capability, yang_name="interface-switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="interface-switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+
+ def _get_label_restrictions(self):
+ """
+ Getter method for label_restrictions, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions (container)
+
+ YANG Description: The label restrictions container.
+ """
+ return self.__label_restrictions
+
+ def _set_label_restrictions(self, v, load=False):
+ """
+ Setter method for label_restrictions, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restrictions is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restrictions() directly.
+
+ YANG Description: The label restrictions container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restrictions must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_restrictions = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restrictions(self):
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_link_protection_type(self):
+ """
+ Getter method for link_protection_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/link_protection_type (identityref)
+
+ YANG Description: Link Protection Type desired for this link.
+ """
+ return self.__link_protection_type
+
+ def _set_link_protection_type(self, v, load=False):
+ """
+ Setter method for link_protection_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/link_protection_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_protection_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_protection_type() directly.
+
+ YANG Description: Link Protection Type desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="link-protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_protection_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="link-protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__link_protection_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_protection_type(self):
+ self.__link_protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="link-protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_max_link_bandwidth(self):
+ """
+ Getter method for max_link_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth (container)
+
+ YANG Description: Maximum bandwidth that can be seen on this link in this
+direction. Units are in bytes per second.
+ """
+ return self.__max_link_bandwidth
+
+ def _set_max_link_bandwidth(self, v, load=False):
+ """
+ Setter method for max_link_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_max_link_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_max_link_bandwidth() directly.
+
+ YANG Description: Maximum bandwidth that can be seen on this link in this
+direction. Units are in bytes per second.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=max_link_bandwidth.max_link_bandwidth, is_container='container', yang_name="max-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """max_link_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=max_link_bandwidth.max_link_bandwidth, is_container='container', yang_name="max-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__max_link_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_max_link_bandwidth(self):
+ self.__max_link_bandwidth = YANGDynClass(base=max_link_bandwidth.max_link_bandwidth, is_container='container', yang_name="max-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_max_resv_link_bandwidth(self):
+ """
+ Getter method for max_resv_link_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth (container)
+
+ YANG Description: Maximum amount of bandwidth that can be reserved in this
+direction in this link. Units are in bytes per second.
+ """
+ return self.__max_resv_link_bandwidth
+
+ def _set_max_resv_link_bandwidth(self, v, load=False):
+ """
+ Setter method for max_resv_link_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_max_resv_link_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_max_resv_link_bandwidth() directly.
+
+ YANG Description: Maximum amount of bandwidth that can be reserved in this
+direction in this link. Units are in bytes per second.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=max_resv_link_bandwidth.max_resv_link_bandwidth, is_container='container', yang_name="max-resv-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """max_resv_link_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=max_resv_link_bandwidth.max_resv_link_bandwidth, is_container='container', yang_name="max-resv-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__max_resv_link_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_max_resv_link_bandwidth(self):
+ self.__max_resv_link_bandwidth = YANGDynClass(base=max_resv_link_bandwidth.max_resv_link_bandwidth, is_container='container', yang_name="max-resv-link-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unreserved_bandwidth(self):
+ """
+ Getter method for unreserved_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth (list)
+
+ YANG Description: Unreserved bandwidth for priority levels 0-7. Units are in
+bytes per second.
+ """
+ return self.__unreserved_bandwidth
+
+ def _set_unreserved_bandwidth(self, v, load=False):
+ """
+ Setter method for unreserved_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unreserved_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unreserved_bandwidth() directly.
+
+ YANG Description: Unreserved bandwidth for priority levels 0-7. Units are in
+bytes per second.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("priority",unreserved_bandwidth.unreserved_bandwidth, yang_name="unreserved-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="unreserved-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unreserved_bandwidth must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("priority",unreserved_bandwidth.unreserved_bandwidth, yang_name="unreserved-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="unreserved-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__unreserved_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unreserved_bandwidth(self):
+ self.__unreserved_bandwidth = YANGDynClass(base=YANGListType("priority",unreserved_bandwidth.unreserved_bandwidth, yang_name="unreserved-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="unreserved-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+
+ def _get_te_default_metric(self):
+ """
+ Getter method for te_default_metric, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_default_metric (uint32)
+
+ YANG Description: Traffic Engineering metric.
+ """
+ return self.__te_default_metric
+
+ def _set_te_default_metric(self, v, load=False):
+ """
+ Setter method for te_default_metric, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_default_metric (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_default_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_default_metric() directly.
+
+ YANG Description: Traffic Engineering metric.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-default-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_default_metric must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-default-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__te_default_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_default_metric(self):
+ self.__te_default_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-default-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_te_delay_metric(self):
+ """
+ Getter method for te_delay_metric, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_delay_metric (uint32)
+
+ YANG Description: Traffic Engineering delay metric.
+ """
+ return self.__te_delay_metric
+
+ def _set_te_delay_metric(self, v, load=False):
+ """
+ Setter method for te_delay_metric, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_delay_metric (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_delay_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_delay_metric() directly.
+
+ YANG Description: Traffic Engineering delay metric.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-delay-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_delay_metric must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-delay-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__te_delay_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_delay_metric(self):
+ self.__te_delay_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-delay-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_te_igp_metric(self):
+ """
+ Getter method for te_igp_metric, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_igp_metric (uint32)
+
+ YANG Description: IGP metric used for Traffic Engineering.
+ """
+ return self.__te_igp_metric
+
+ def _set_te_igp_metric(self, v, load=False):
+ """
+ Setter method for te_igp_metric, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_igp_metric (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_igp_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_igp_metric() directly.
+
+ YANG Description: IGP metric used for Traffic Engineering.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-igp-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_igp_metric must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-igp-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__te_igp_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_igp_metric(self):
+ self.__te_igp_metric = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="te-igp-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_te_srlgs(self):
+ """
+ Getter method for te_srlgs, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_srlgs (container)
+
+ YANG Description: Contains a list of SRLGs.
+ """
+ return self.__te_srlgs
+
+ def _set_te_srlgs(self, v, load=False):
+ """
+ Setter method for te_srlgs, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_srlgs (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_srlgs is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_srlgs() directly.
+
+ YANG Description: Contains a list of SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_srlgs.te_srlgs, is_container='container', yang_name="te-srlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_srlgs must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_srlgs.te_srlgs, is_container='container', yang_name="te-srlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_srlgs = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_srlgs(self):
+ self.__te_srlgs = YANGDynClass(base=te_srlgs.te_srlgs, is_container='container', yang_name="te-srlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_te_nsrlgs(self):
+ """
+ Getter method for te_nsrlgs, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_nsrlgs (container)
+
+ YANG Description: Contains a list of NSRLGs (Non-Shared Risk Link Groups).
+When an abstract TE link is configured, this list specifies
+the request that underlay TE paths need to be mutually
+disjoint with other TE links in the same groups.
+ """
+ return self.__te_nsrlgs
+
+ def _set_te_nsrlgs(self, v, load=False):
+ """
+ Setter method for te_nsrlgs, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_nsrlgs (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_nsrlgs is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_nsrlgs() directly.
+
+ YANG Description: Contains a list of NSRLGs (Non-Shared Risk Link Groups).
+When an abstract TE link is configured, this list specifies
+the request that underlay TE paths need to be mutually
+disjoint with other TE links in the same groups.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_nsrlgs.te_nsrlgs, is_container='container', yang_name="te-nsrlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_nsrlgs must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_nsrlgs.te_nsrlgs, is_container='container', yang_name="te-nsrlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_nsrlgs = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_nsrlgs(self):
+ self.__te_nsrlgs = YANGDynClass(base=te_nsrlgs.te_nsrlgs, is_container='container', yang_name="te-nsrlgs", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_otn_link(self):
+ """
+ Getter method for otn_link, mapped from YANG variable /networks/network/link/te/te_link_attributes/otn_link (container)
+
+ YANG Description: Attributes of the OTN Link.
+ """
+ return self.__otn_link
+
+ def _set_otn_link(self, v, load=False):
+ """
+ Setter method for otn_link, mapped from YANG variable /networks/network/link/te/te_link_attributes/otn_link (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_link is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_link() directly.
+
+ YANG Description: Attributes of the OTN Link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_link.otn_link, is_container='container', yang_name="otn-link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_link must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_link.otn_link, is_container='container', yang_name="otn-link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn_link = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_link(self):
+ self.__otn_link = YANGDynClass(base=otn_link.otn_link, is_container='container', yang_name="otn-link", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_client_svc(self):
+ """
+ Getter method for client_svc, mapped from YANG variable /networks/network/link/te/te_link_attributes/client_svc (container)
+
+ YANG Description: Attributes of the Link supporting CBR client signals.
+ """
+ return self.__client_svc
+
+ def _set_client_svc(self, v, load=False):
+ """
+ Setter method for client_svc, mapped from YANG variable /networks/network/link/te/te_link_attributes/client_svc (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_client_svc is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_client_svc() directly.
+
+ YANG Description: Attributes of the Link supporting CBR client signals.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=client_svc.client_svc, is_container='container', yang_name="client-svc", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """client_svc must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=client_svc.client_svc, is_container='container', yang_name="client-svc", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__client_svc = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_client_svc(self):
+ self.__client_svc = YANGDynClass(base=client_svc.client_svc, is_container='container', yang_name="client-svc", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+ access_type = __builtin__.property(_get_access_type, _set_access_type)
+ external_domain = __builtin__.property(_get_external_domain, _set_external_domain)
+ is_abstract = __builtin__.property(_get_is_abstract, _set_is_abstract)
+ name = __builtin__.property(_get_name, _set_name)
+ underlay = __builtin__.property(_get_underlay, _set_underlay)
+ admin_status = __builtin__.property(_get_admin_status, _set_admin_status)
+ link_index = __builtin__.property(_get_link_index, _set_link_index)
+ administrative_group = __builtin__.property(_get_administrative_group, _set_administrative_group)
+ interface_switching_capability = __builtin__.property(_get_interface_switching_capability, _set_interface_switching_capability)
+ label_restrictions = __builtin__.property(_get_label_restrictions, _set_label_restrictions)
+ link_protection_type = __builtin__.property(_get_link_protection_type, _set_link_protection_type)
+ max_link_bandwidth = __builtin__.property(_get_max_link_bandwidth, _set_max_link_bandwidth)
+ max_resv_link_bandwidth = __builtin__.property(_get_max_resv_link_bandwidth, _set_max_resv_link_bandwidth)
+ unreserved_bandwidth = __builtin__.property(_get_unreserved_bandwidth, _set_unreserved_bandwidth)
+ te_default_metric = __builtin__.property(_get_te_default_metric, _set_te_default_metric)
+ te_delay_metric = __builtin__.property(_get_te_delay_metric, _set_te_delay_metric)
+ te_igp_metric = __builtin__.property(_get_te_igp_metric, _set_te_igp_metric)
+ te_srlgs = __builtin__.property(_get_te_srlgs, _set_te_srlgs)
+ te_nsrlgs = __builtin__.property(_get_te_nsrlgs, _set_te_nsrlgs)
+ otn_link = __builtin__.property(_get_otn_link, _set_otn_link)
+ client_svc = __builtin__.property(_get_client_svc, _set_client_svc)
+
+
+ _pyangbind_elements = OrderedDict([('access_type', access_type), ('external_domain', external_domain), ('is_abstract', is_abstract), ('name', name), ('underlay', underlay), ('admin_status', admin_status), ('link_index', link_index), ('administrative_group', administrative_group), ('interface_switching_capability', interface_switching_capability), ('label_restrictions', label_restrictions), ('link_protection_type', link_protection_type), ('max_link_bandwidth', max_link_bandwidth), ('max_resv_link_bandwidth', max_resv_link_bandwidth), ('unreserved_bandwidth', unreserved_bandwidth), ('te_default_metric', te_default_metric), ('te_delay_metric', te_delay_metric), ('te_igp_metric', te_igp_metric), ('te_srlgs', te_srlgs), ('te_nsrlgs', te_nsrlgs), ('otn_link', otn_link), ('client_svc', client_svc), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/client_svc/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/client_svc/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..69ba52bbc1f3cd59eea7b26cf14885731e978925
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/client_svc/__init__.py
@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class client_svc(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/client-svc. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Attributes of the Link supporting CBR client signals.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__supported_client_signal',)
+
+ _yang_name = 'client-svc'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__supported_client_signal = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="supported-client-signal", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'client-svc']
+
+ def _get_supported_client_signal(self):
+ """
+ Getter method for supported_client_signal, mapped from YANG variable /networks/network/link/te/te_link_attributes/client_svc/supported_client_signal (identityref)
+
+ YANG Description: List of client signal types supported by the Link.
+ """
+ return self.__supported_client_signal
+
+ def _set_supported_client_signal(self, v, load=False):
+ """
+ Setter method for supported_client_signal, mapped from YANG variable /networks/network/link/te/te_link_attributes/client_svc/supported_client_signal (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_supported_client_signal is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_supported_client_signal() directly.
+
+ YANG Description: List of client signal types supported by the Link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="supported-client-signal", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """supported_client_signal must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="supported-client-signal", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__supported_client_signal = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_supported_client_signal(self):
+ self.__supported_client_signal = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-1Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-10Gb-LAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-10Gb-WAN': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-40Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ETH-100Gb': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-16': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-64': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:STM-256': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-12': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-48': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-192': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:OC-768': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-100': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-400': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-800': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-1200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-1600': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FC-3200': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FICON-4G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:FICON-8G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="supported-client-signal", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+ supported_client_signal = __builtin__.property(_get_supported_client_signal, _set_supported_client_signal)
+
+
+ _pyangbind_elements = OrderedDict([('supported_client_signal', supported_client_signal), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/external_domain/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/external_domain/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..adc0d23fb6e1d7573a6686a7b049a3bccf0a2dd3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/external_domain/__init__.py
@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class external_domain(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/external-domain. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: For an inter-domain link, specifies the attributes of
+the remote end of the link, to facilitate the signaling at
+the local end.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref','__remote_te_node_id','__remote_te_link_tp_id',)
+
+ _yang_name = 'external-domain'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__remote_te_node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="remote-te-node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-node-id', is_config=True)
+ self.__remote_te_link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="remote-te-link-tp-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-tp-id', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'external-domain']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/link/te/te_link_attributes/external_domain/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/link/te/te_link_attributes/external_domain/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_remote_te_node_id(self):
+ """
+ Getter method for remote_te_node_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/external_domain/remote_te_node_id (te-types:te-node-id)
+
+ YANG Description: Remote TE node identifier, used together with
+'remote-te-link-tp-id' to identify the remote Link
+Termination Point (LTP) in a different domain.
+ """
+ return self.__remote_te_node_id
+
+ def _set_remote_te_node_id(self, v, load=False):
+ """
+ Setter method for remote_te_node_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/external_domain/remote_te_node_id (te-types:te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_remote_te_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_remote_te_node_id() directly.
+
+ YANG Description: Remote TE node identifier, used together with
+'remote-te-link-tp-id' to identify the remote Link
+Termination Point (LTP) in a different domain.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="remote-te-node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """remote_te_node_id must be of a type compatible with te-types:te-node-id""",
+ 'defined-type': "te-types:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="remote-te-node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-node-id', is_config=True)""",
+ })
+
+ self.__remote_te_node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_remote_te_node_id(self):
+ self.__remote_te_node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="remote-te-node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-node-id', is_config=True)
+
+
+ def _get_remote_te_link_tp_id(self):
+ """
+ Getter method for remote_te_link_tp_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/external_domain/remote_te_link_tp_id (te-types:te-tp-id)
+
+ YANG Description: Remote TE LTP identifier, used together with
+'remote-te-node-id' to identify the remote LTP in a
+different domain.
+ """
+ return self.__remote_te_link_tp_id
+
+ def _set_remote_te_link_tp_id(self, v, load=False):
+ """
+ Setter method for remote_te_link_tp_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/external_domain/remote_te_link_tp_id (te-types:te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_remote_te_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_remote_te_link_tp_id() directly.
+
+ YANG Description: Remote TE LTP identifier, used together with
+'remote-te-node-id' to identify the remote LTP in a
+different domain.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="remote-te-link-tp-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """remote_te_link_tp_id must be of a type compatible with te-types:te-tp-id""",
+ 'defined-type': "te-types:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="remote-te-link-tp-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-tp-id', is_config=True)""",
+ })
+
+ self.__remote_te_link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_remote_te_link_tp_id(self):
+ self.__remote_te_link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="remote-te-link-tp-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-tp-id', is_config=True)
+
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ remote_te_node_id = __builtin__.property(_get_remote_te_node_id, _set_remote_te_node_id)
+ remote_te_link_tp_id = __builtin__.property(_get_remote_te_link_tp_id, _set_remote_te_link_tp_id)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ('remote_te_node_id', remote_te_node_id), ('remote_te_link_tp_id', remote_te_link_tp_id), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e999df8fd7004d8a4ff893b3c470c52dbd6076b6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/__init__.py
@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import max_lsp_bandwidth
+class interface_switching_capability(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/interface-switching-capability. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of ISCDs for this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__switching_capability','__encoding','__max_lsp_bandwidth',)
+
+ _yang_name = 'interface-switching-capability'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__switching_capability = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__encoding = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__max_lsp_bandwidth = YANGDynClass(base=YANGListType("priority",max_lsp_bandwidth.max_lsp_bandwidth, yang_name="max-lsp-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="max-lsp-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'interface-switching-capability']
+
+ def _get_switching_capability(self):
+ """
+ Getter method for switching_capability, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/switching_capability (identityref)
+
+ YANG Description: Switching capability for this interface.
+ """
+ return self.__switching_capability
+
+ def _set_switching_capability(self, v, load=False):
+ """
+ Setter method for switching_capability, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/switching_capability (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_switching_capability is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_switching_capability() directly.
+
+ YANG Description: Switching capability for this interface.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """switching_capability must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__switching_capability = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_switching_capability(self):
+ self.__switching_capability = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_encoding(self):
+ """
+ Getter method for encoding, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/encoding (identityref)
+
+ YANG Description: Encoding supported by this interface.
+ """
+ return self.__encoding
+
+ def _set_encoding(self, v, load=False):
+ """
+ Setter method for encoding, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/encoding (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_encoding is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_encoding() directly.
+
+ YANG Description: Encoding supported by this interface.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """encoding must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__encoding = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_encoding(self):
+ self.__encoding = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_max_lsp_bandwidth(self):
+ """
+ Getter method for max_lsp_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth (list)
+
+ YANG Description: Maximum Label Switched Path (LSP) bandwidth at
+priorities 0-7.
+ """
+ return self.__max_lsp_bandwidth
+
+ def _set_max_lsp_bandwidth(self, v, load=False):
+ """
+ Setter method for max_lsp_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_max_lsp_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_max_lsp_bandwidth() directly.
+
+ YANG Description: Maximum Label Switched Path (LSP) bandwidth at
+priorities 0-7.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("priority",max_lsp_bandwidth.max_lsp_bandwidth, yang_name="max-lsp-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="max-lsp-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """max_lsp_bandwidth must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("priority",max_lsp_bandwidth.max_lsp_bandwidth, yang_name="max-lsp-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="max-lsp-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__max_lsp_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_max_lsp_bandwidth(self):
+ self.__max_lsp_bandwidth = YANGDynClass(base=YANGListType("priority",max_lsp_bandwidth.max_lsp_bandwidth, yang_name="max-lsp-bandwidth", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='priority', extensions=None), is_container='list', yang_name="max-lsp-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ switching_capability = __builtin__.property(_get_switching_capability, _set_switching_capability)
+ encoding = __builtin__.property(_get_encoding, _set_encoding)
+ max_lsp_bandwidth = __builtin__.property(_get_max_lsp_bandwidth, _set_max_lsp_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('switching_capability', switching_capability), ('encoding', encoding), ('max_lsp_bandwidth', max_lsp_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd066564c019446b9f1d290725548dd988592cfa
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/__init__.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+class max_lsp_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/interface-switching-capability/max-lsp-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Maximum Label Switched Path (LSP) bandwidth at
+priorities 0-7.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__priority','__te_bandwidth',)
+
+ _yang_name = 'max-lsp-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'interface-switching-capability', 'max-lsp-bandwidth']
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/priority (uint8)
+
+ YANG Description: Priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ priority = __builtin__.property(_get_priority, _set_priority)
+ te_bandwidth = __builtin__.property(_get_te_bandwidth, _set_te_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('priority', priority), ('te_bandwidth', te_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae1f4655b617b424563ff1a67918aca3aa745d15
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/interface-switching-capability/max-lsp-bandwidth/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'interface-switching-capability', 'max-lsp-bandwidth', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn (container)
+
+ YANG Description: Maximum bandwidth attributes for OTN paths.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Maximum bandwidth attributes for OTN paths.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth, _set_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_bandwidth']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..714d3fac7bdc67f8355b240a8d6b2975aeeaf415
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/__init__.py
@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/interface-switching-capability/max-lsp-bandwidth/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Maximum bandwidth attributes for OTN paths.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__max_ts_number',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__max_ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="max-ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'interface-switching-capability', 'max-lsp-bandwidth', 'te-bandwidth', 'otn']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_max_ts_number(self):
+ """
+ Getter method for max_ts_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/max_ts_number (uint16)
+
+ YANG Description: The maximum number of Tributary Slots (TS) that could be
+used by an ODUflex LSP.
+ """
+ return self.__max_ts_number
+
+ def _set_max_ts_number(self, v, load=False):
+ """
+ Setter method for max_ts_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/otn/max_ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_max_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_max_ts_number() directly.
+
+ YANG Description: The maximum number of Tributary Slots (TS) that could be
+used by an ODUflex LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="max-ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """max_ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="max-ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__max_ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_max_ts_number(self):
+ self.__max_ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="max-ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ odu_type = __builtin__.property(_get_odu_type, _set_odu_type)
+ max_ts_number = __builtin__.property(_get_max_ts_number, _set_max_ts_number)
+
+ __choices__ = {'technology': {'otn': ['odu_type', 'max_ts_number']}}
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('max_ts_number', max_ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4e44b0e9dd6557014d1255c5cf76f22fdca0ded
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restriction
+class label_restrictions(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The label restrictions container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__label_restriction',)
+
+ _yang_name = 'label-restrictions'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions']
+
+ def _get_label_restriction(self):
+ """
+ Getter method for label_restriction, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction (list)
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ return self.__label_restriction
+
+ def _set_label_restriction(self, v, load=False):
+ """
+ Setter method for label_restriction, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restriction() directly.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restriction must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__label_restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restriction(self):
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ label_restriction = __builtin__.property(_get_label_restriction, _set_label_restriction)
+
+
+ _pyangbind_elements = OrderedDict([('label_restriction', label_restriction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..44f0812775abb236b1da05700735e632fe9ef6c7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/__init__.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_start
+from . import label_end
+from . import label_step
+from . import otn_label_range
+from . import ethernet_label_range
+class label_restriction(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restriction','__index','__label_start','__label_end','__label_step','__range_bitmap','__otn_label_range','__ethernet_label_range',)
+
+ _yang_name = 'label-restriction'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction']
+
+ def _get_restriction(self):
+ """
+ Getter method for restriction, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/restriction (enumeration)
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ return self.__restriction
+
+ def _set_restriction(self, v, load=False):
+ """
+ Setter method for restriction, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/restriction (enumeration)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restriction() directly.
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restriction must be of a type compatible with enumeration""",
+ 'defined-type': "ietf-te-topology:enumeration",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)""",
+ })
+
+ self.__restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restriction(self):
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/index (uint32)
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_label_start(self):
+ """
+ Getter method for label_start, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start (container)
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ return self.__label_start
+
+ def _set_label_start(self, v, load=False):
+ """
+ Setter method for label_start, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_start is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_start() directly.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_start must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_start = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_start(self):
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_end(self):
+ """
+ Getter method for label_end, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end (container)
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ return self.__label_end
+
+ def _set_label_end(self, v, load=False):
+ """
+ Setter method for label_end, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_end is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_end() directly.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_end must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_end = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_end(self):
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_step(self):
+ """
+ Getter method for label_step, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step (container)
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ return self.__label_step
+
+ def _set_label_step(self, v, load=False):
+ """
+ Setter method for label_step, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_step() directly.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_step must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_step(self):
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_range_bitmap(self):
+ """
+ Getter method for range_bitmap, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ return self.__range_bitmap
+
+ def _set_range_bitmap(self, v, load=False):
+ """
+ Setter method for range_bitmap, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_bitmap is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_bitmap() directly.
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_bitmap must be of a type compatible with yang:hex-string""",
+ 'defined-type': "yang:hex-string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)""",
+ })
+
+ self.__range_bitmap = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_bitmap(self):
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+
+
+ def _get_otn_label_range(self):
+ """
+ Getter method for otn_label_range, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range (container)
+
+ YANG Description: Label range information for OTN.
+ """
+ return self.__otn_label_range
+
+ def _set_otn_label_range(self, v, load=False):
+ """
+ Setter method for otn_label_range, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_label_range() directly.
+
+ YANG Description: Label range information for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_label_range(self):
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_ethernet_label_range(self):
+ """
+ Getter method for ethernet_label_range, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/ethernet_label_range (container)
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ return self.__ethernet_label_range
+
+ def _set_ethernet_label_range(self, v, load=False):
+ """
+ Setter method for ethernet_label_range, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/ethernet_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ethernet_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ethernet_label_range() directly.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ethernet_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__ethernet_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ethernet_label_range(self):
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ restriction = __builtin__.property(_get_restriction, _set_restriction)
+ index = __builtin__.property(_get_index, _set_index)
+ label_start = __builtin__.property(_get_label_start, _set_label_start)
+ label_end = __builtin__.property(_get_label_end, _set_label_end)
+ label_step = __builtin__.property(_get_label_step, _set_label_step)
+ range_bitmap = __builtin__.property(_get_range_bitmap, _set_range_bitmap)
+ otn_label_range = __builtin__.property(_get_otn_label_range, _set_otn_label_range)
+ ethernet_label_range = __builtin__.property(_get_ethernet_label_range, _set_ethernet_label_range)
+
+
+ _pyangbind_elements = OrderedDict([('restriction', restriction), ('index', index), ('label_start', label_start), ('label_end', label_end), ('label_step', label_step), ('range_bitmap', range_bitmap), ('otn_label_range', otn_label_range), ('ethernet_label_range', ethernet_label_range), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/ethernet_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/ethernet_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..52e6a65c17f8e1dc93617d8d83c97d1264f7c66d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/ethernet_label_range/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ethernet_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction/ethernet-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tag_type','__priority',)
+
+ _yang_name = 'ethernet-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction', 'ethernet-label-range']
+
+ def _get_tag_type(self):
+ """
+ Getter method for tag_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+
+ YANG Description: VLAN tag type.
+ """
+ return self.__tag_type
+
+ def _set_tag_type(self, v, load=False):
+ """
+ Setter method for tag_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tag_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tag_type() directly.
+
+ YANG Description: VLAN tag type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tag_type must be of a type compatible with etht-types:eth-tag-type""",
+ 'defined-type': "etht-types:eth-tag-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)""",
+ })
+
+ self.__tag_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tag_type(self):
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+
+ YANG Description: priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ tag_type = __builtin__.property(_get_tag_type, _set_tag_type)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('tag_type', tag_type), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac25e0634b6d08a4574177f2ff1630f4a2b2496f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_end(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction/label-end. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-end'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction', 'label-end']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..67dde90521ef28bc7f60fd4de11958b9383db32b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction/label-end/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction', 'label-end', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..24875829b97bd7c53e734cb3a60b1730eac4694a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction/label-end/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction', 'label-end', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..65fb7f8e1624aee0aa322c455c72558add6d54d3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_start(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction/label-start. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-start'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction', 'label-start']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a68961e3223f9bcfa8f06bac656a0d58279c7fe
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction/label-start/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction', 'label-start', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..082f89723c1a7ce0382b9266cd665359ac29e533
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction/label-start/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction', 'label-start', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..51201035a600a310728cb184967cfd0295c1bb04
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class label_step(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction/label-step. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_step',)
+
+ _yang_name = 'label-step'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction', 'label-step']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/generic (int32)
+
+ YANG Description: Label range step.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/generic (int32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Label range step.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with int32""",
+ 'defined-type': "int32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/otn (container)
+
+ YANG Description: Label step for OTN
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label step for OTN
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_step(self):
+ """
+ Getter method for eth_step, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/eth_step (uint16)
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ return self.__eth_step
+
+ def _set_eth_step(self, v, load=False):
+ """
+ Setter method for eth_step, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/eth_step (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_step() directly.
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_step must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__eth_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_step(self):
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_step = __builtin__.property(_get_eth_step, _set_eth_step)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_step']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_step', eth_step), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1325a1afdeebef2b7141462c193da301279412ea
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/otn/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction/label-step/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label step for OTN
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction', 'label-step', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b59c995b2870f460b03de3af569ff6b7fd1d9bea
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/label-restrictions/label-restriction/otn-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label range information for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__range_type','__tsg','__odu_type_list','__priority',)
+
+ _yang_name = 'otn-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'label-restrictions', 'label-restriction', 'otn-label-range']
+
+ def _get_range_type(self):
+ """
+ Getter method for range_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ return self.__range_type
+
+ def _set_range_type(self, v, load=False):
+ """
+ Setter method for range_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_type() directly.
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_type must be of a type compatible with otn-label-range-type""",
+ 'defined-type': "ietf-otn-topology:otn-label-range-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)""",
+ })
+
+ self.__range_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_type(self):
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_odu_type_list(self):
+ """
+ Getter method for odu_type_list, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ return self.__odu_type_list
+
+ def _set_odu_type_list(self, v, load=False):
+ """
+ Setter method for odu_type_list, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type_list() directly.
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type_list must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type_list(self):
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ range_type = __builtin__.property(_get_range_type, _set_range_type)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ odu_type_list = __builtin__.property(_get_odu_type_list, _set_odu_type_list)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('range_type', range_type), ('tsg', tsg), ('odu_type_list', odu_type_list), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..566cf779960e7da8cd888ced53ed38b2e79f8fcf
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+class max_link_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/max-link-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Maximum bandwidth that can be seen on this link in this
+direction. Units are in bytes per second.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_bandwidth',)
+
+ _yang_name = 'max-link-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'max-link-bandwidth']
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_bandwidth = __builtin__.property(_get_te_bandwidth, _set_te_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('te_bandwidth', te_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0e0c9a78aab5fa13c8b166c9eb1e3374e31bc2d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/max-link-bandwidth/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'max-link-bandwidth', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth, _set_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..94132f930254b1e06ff745c118b01a4511b75f1b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/max-link-bandwidth/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'max-link-bandwidth', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+
+ odulist = __builtin__.property(_get_odulist, _set_odulist)
+
+
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..53a6ab8739a937f1c33d42b7ac93cabddf249521
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/max-link-bandwidth/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'max-link-bandwidth', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ odu_type = __builtin__.property(_get_odu_type, _set_odu_type)
+ number = __builtin__.property(_get_number, _set_number)
+ ts_number = __builtin__.property(_get_ts_number, _set_ts_number)
+
+
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..33d25351b1f49adbc787e667e557f3cf3de3f387
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+class max_resv_link_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/max-resv-link-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Maximum amount of bandwidth that can be reserved in this
+direction in this link. Units are in bytes per second.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_bandwidth',)
+
+ _yang_name = 'max-resv-link-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'max-resv-link-bandwidth']
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_bandwidth = __builtin__.property(_get_te_bandwidth, _set_te_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('te_bandwidth', te_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..34072dafa69abb467c6e46d7f7ee550119244547
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/max-resv-link-bandwidth/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'max-resv-link-bandwidth', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth, _set_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..971708460d371d869013e6eb51c35bbca416cc87
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/max-resv-link-bandwidth/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'max-resv-link-bandwidth', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+
+ odulist = __builtin__.property(_get_odulist, _set_odulist)
+
+
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ee145707c3270bee11e71ad357fb1c6df8fe5d0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/max-resv-link-bandwidth/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'max-resv-link-bandwidth', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ odu_type = __builtin__.property(_get_odu_type, _set_odu_type)
+ number = __builtin__.property(_get_number, _set_number)
+ ts_number = __builtin__.property(_get_ts_number, _set_ts_number)
+
+
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/otn_link/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/otn_link/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..62dec2b8900c4567216707abd01d79e8e567f631
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/otn_link/__init__.py
@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_link(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/otn-link. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Attributes of the OTN Link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odtu_flex_type','__tsg','__distance',)
+
+ _yang_name = 'otn-link'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__distance = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="distance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint32', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'otn-link']
+
+ def _get_odtu_flex_type(self):
+ """
+ Getter method for odtu_flex_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/otn_link/odtu_flex_type (l1-types:odtu-flex-type)
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs set up
+on this OTN Link.
+ """
+ return self.__odtu_flex_type
+
+ def _set_odtu_flex_type(self, v, load=False):
+ """
+ Setter method for odtu_flex_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/otn_link/odtu_flex_type (l1-types:odtu-flex-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odtu_flex_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odtu_flex_type() directly.
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs set up
+on this OTN Link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odtu_flex_type must be of a type compatible with l1-types:odtu-flex-type""",
+ 'defined-type': "l1-types:odtu-flex-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)""",
+ })
+
+ self.__odtu_flex_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odtu_flex_type(self):
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/link/te/te_link_attributes/otn_link/tsg (identityref)
+
+ YANG Description: Tributary slot granularity.
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/link/te/te_link_attributes/otn_link/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_distance(self):
+ """
+ Getter method for distance, mapped from YANG variable /networks/network/link/te/te_link_attributes/otn_link/distance (uint32)
+
+ YANG Description: distance in the unit of kilometers
+ """
+ return self.__distance
+
+ def _set_distance(self, v, load=False):
+ """
+ Setter method for distance, mapped from YANG variable /networks/network/link/te/te_link_attributes/otn_link/distance (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_distance is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_distance() directly.
+
+ YANG Description: distance in the unit of kilometers
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="distance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """distance must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="distance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__distance = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_distance(self):
+ self.__distance = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="distance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint32', is_config=True)
+
+ odtu_flex_type = __builtin__.property(_get_odtu_flex_type, _set_odtu_flex_type)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ distance = __builtin__.property(_get_distance, _set_distance)
+
+
+ _pyangbind_elements = OrderedDict([('odtu_flex_type', odtu_flex_type), ('tsg', tsg), ('distance', distance), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/te_nsrlgs/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/te_nsrlgs/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..51926d3135bc483730723c3ee73ed2b4201ea38c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/te_nsrlgs/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class te_nsrlgs(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/te-nsrlgs. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains a list of NSRLGs (Non-Shared Risk Link Groups).
+When an abstract TE link is configured, this list specifies
+the request that underlay TE paths need to be mutually
+disjoint with other TE links in the same groups.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__id',)
+
+ _yang_name = 'te-nsrlgs'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__id = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'te-nsrlgs']
+
+ def _get_id(self):
+ """
+ Getter method for id, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_nsrlgs/id (uint32)
+
+ YANG Description: NSRLG ID, uniquely configured within a topology.
+ """
+ return self.__id
+
+ def _set_id(self, v, load=False):
+ """
+ Setter method for id, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_nsrlgs/id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_id() directly.
+
+ YANG Description: NSRLG ID, uniquely configured within a topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_id(self):
+ self.__id = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+ id = __builtin__.property(_get_id, _set_id)
+
+
+ _pyangbind_elements = OrderedDict([('id', id), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/te_srlgs/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/te_srlgs/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..92ac61644757fb7d4aad97d30d818e3f496f526e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/te_srlgs/__init__.py
@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class te_srlgs(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/te-srlgs. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains a list of SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__value',)
+
+ _yang_name = 'te-srlgs'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__value = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:srlg', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'te-srlgs']
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_srlgs/value (te-types:srlg)
+
+ YANG Description: SRLG value.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/link/te/te_link_attributes/te_srlgs/value (te-types:srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: SRLG value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:srlg', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with te-types:srlg""",
+ 'defined-type': "te-types:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:srlg', is_config=True)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:srlg', is_config=True)
+
+ value = __builtin__.property(_get_value, _set_value)
+
+
+ _pyangbind_elements = OrderedDict([('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..129490e773c092f4dfeb730380f9bfd6f63158c8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/__init__.py
@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import primary_path
+from . import backup_path
+from . import tunnel_termination_points
+from . import tunnels
+class underlay(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__enabled','__primary_path','__backup_path','__protection_type','__tunnel_termination_points','__tunnels',)
+
+ _yang_name = 'underlay'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay']
+
+ def _get_enabled(self):
+ """
+ Getter method for enabled, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/enabled (boolean)
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ return self.__enabled
+
+ def _set_enabled(self, v, load=False):
+ """
+ Setter method for enabled, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/enabled (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_enabled is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_enabled() directly.
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """enabled must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__enabled = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_enabled(self):
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_primary_path(self):
+ """
+ Getter method for primary_path, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path (container)
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ return self.__primary_path
+
+ def _set_primary_path(self, v, load=False):
+ """
+ Setter method for primary_path, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_primary_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_primary_path() directly.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """primary_path must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__primary_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_primary_path(self):
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_backup_path(self):
+ """
+ Getter method for backup_path, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path (list)
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ return self.__backup_path
+
+ def _set_backup_path(self, v, load=False):
+ """
+ Setter method for backup_path, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_backup_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_backup_path() directly.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """backup_path must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__backup_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_backup_path(self):
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+
+ def _get_protection_type(self):
+ """
+ Getter method for protection_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/protection_type (identityref)
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ return self.__protection_type
+
+ def _set_protection_type(self, v, load=False):
+ """
+ Setter method for protection_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/protection_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_protection_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_protection_type() directly.
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """protection_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__protection_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_protection_type(self):
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_tunnel_termination_points(self):
+ """
+ Getter method for tunnel_termination_points, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points (container)
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ return self.__tunnel_termination_points
+
+ def _set_tunnel_termination_points(self, v, load=False):
+ """
+ Setter method for tunnel_termination_points, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_termination_points is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_termination_points() directly.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_termination_points must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tunnel_termination_points = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_termination_points(self):
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_tunnels(self):
+ """
+ Getter method for tunnels, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnels (container)
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ return self.__tunnels
+
+ def _set_tunnels(self, v, load=False):
+ """
+ Setter method for tunnels, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnels (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnels is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnels() directly.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnels must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tunnels = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnels(self):
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ enabled = __builtin__.property(_get_enabled, _set_enabled)
+ primary_path = __builtin__.property(_get_primary_path, _set_primary_path)
+ backup_path = __builtin__.property(_get_backup_path, _set_backup_path)
+ protection_type = __builtin__.property(_get_protection_type, _set_protection_type)
+ tunnel_termination_points = __builtin__.property(_get_tunnel_termination_points, _set_tunnel_termination_points)
+ tunnels = __builtin__.property(_get_tunnels, _set_tunnels)
+
+
+ _pyangbind_elements = OrderedDict([('enabled', enabled), ('primary_path', primary_path), ('backup_path', backup_path), ('protection_type', protection_type), ('tunnel_termination_points', tunnel_termination_points), ('tunnels', tunnels), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e430aedb3678a19f425b9df6afd510c0a5a40eb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/__init__.py
@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class backup_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/backup-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__network_ref','__path_element',)
+
+ _yang_name = 'backup-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'backup-path']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/index (uint32)
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element (list)
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ path_element = __builtin__.property(_get_path_element, _set_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('index', index), ('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..aca211807fc5946c59ac378a1fe43764cf342f48
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/__init__.py
@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/backup-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'backup-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ path_element_id = __builtin__.property(_get_path_element_id, _set_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3613095739ab1dda42e1ee56bfd2410e73111288
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/backup-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'backup-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9ec35dbe9b20e8c7925632ccb72415340368201
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/backup-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'backup-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e91ab131548adfa142ddf87e34ce02d3a89638c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/backup-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb2e02afeb4d26363c3e3b4ca5b38d9ea1bb831e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/backup-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..06923495db9b049ac32d9f799c0b0793b7583a39
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/backup-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'backup-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..24687817713ab1d51b59ca694c621be191e53ea5
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/backup-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'backup-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b040726e4af3bfebb68e9584bd6d60eb9fb5082
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/backup-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'backup-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cbefb38a259de886eefbd7db230a93ba58a62a7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class primary_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/primary-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref','__path_element',)
+
+ _yang_name = 'primary-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'primary-path']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element (list)
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ path_element = __builtin__.property(_get_path_element, _set_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1f9ba7c64066aca0fc7de0aa7e80f76b731e675
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/__init__.py
@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/primary-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'primary-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ path_element_id = __builtin__.property(_get_path_element_id, _set_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..be898e3aae7fc97049bd45468088608d37ceac84
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/primary-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'primary-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..46d140192c590c9c1df54170cec68de0382e2c2f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/primary-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'primary-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3aee6e73b3049dd3deaff121618e076d718c68fc
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/primary-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..30e2c479a2ba0bd1dcf916efa4f39705b62ed1b1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/primary-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..88d8af789152ed19bc3fd9635abaaf57a89e422f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/primary-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'primary-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe386ce02952a8bb2e7192b274a4705c27c4c40d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/primary-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'primary-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..130901543218adc5066d8a5d062670d62db66a46
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/primary-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'primary-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b516827dcd8b813b46797cba3ac2091dc776515
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel_termination_points(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/tunnel-termination-points. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__source','__destination',)
+
+ _yang_name = 'tunnel-termination-points'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'tunnel-termination-points']
+
+ def _get_source(self):
+ """
+ Getter method for source, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points/source (binary)
+
+ YANG Description: Source TTP identifier.
+ """
+ return self.__source
+
+ def _set_source(self, v, load=False):
+ """
+ Setter method for source, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points/source (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_source() directly.
+
+ YANG Description: Source TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """source must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)""",
+ })
+
+ self.__source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_source(self):
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+
+ def _get_destination(self):
+ """
+ Getter method for destination, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points/destination (binary)
+
+ YANG Description: Destination TTP identifier.
+ """
+ return self.__destination
+
+ def _set_destination(self, v, load=False):
+ """
+ Setter method for destination, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points/destination (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_destination is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_destination() directly.
+
+ YANG Description: Destination TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """destination must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)""",
+ })
+
+ self.__destination = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_destination(self):
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+ source = __builtin__.property(_get_source, _set_source)
+ destination = __builtin__.property(_get_destination, _set_destination)
+
+
+ _pyangbind_elements = OrderedDict([('source', source), ('destination', destination), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4402db40ec66aff67c7a0cfc860e603e9990c7b2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/__init__.py
@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tunnel
+class tunnels(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/tunnels. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__sharing','__tunnel',)
+
+ _yang_name = 'tunnels'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'tunnels']
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnels/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnels/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_tunnel(self):
+ """
+ Getter method for tunnel, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel (list)
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ return self.__tunnel
+
+ def _set_tunnel(self, v, load=False):
+ """
+ Setter method for tunnel, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel() directly.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__tunnel = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel(self):
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ sharing = __builtin__.property(_get_sharing, _set_sharing)
+ tunnel = __builtin__.property(_get_tunnel, _set_tunnel)
+
+
+ _pyangbind_elements = OrderedDict([('sharing', sharing), ('tunnel', tunnel), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfd6fae3f3acb313d064cd6ae1f77fd068e3b838
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel/__init__.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/underlay/tunnels/tunnel. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tunnel_name','__sharing',)
+
+ _yang_name = 'tunnel'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'underlay', 'tunnels', 'tunnel']
+
+ def _get_tunnel_name(self):
+ """
+ Getter method for tunnel_name, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel/tunnel_name (string)
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ return self.__tunnel_name
+
+ def _set_tunnel_name(self, v, load=False):
+ """
+ Setter method for tunnel_name, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel/tunnel_name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_name() directly.
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__tunnel_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_name(self):
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+ tunnel_name = __builtin__.property(_get_tunnel_name, _set_tunnel_name)
+ sharing = __builtin__.property(_get_sharing, _set_sharing)
+
+
+ _pyangbind_elements = OrderedDict([('tunnel_name', tunnel_name), ('sharing', sharing), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..64b36f07a78fe03bee92be19c211885a3b77c25f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/__init__.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+class unreserved_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/unreserved-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unreserved bandwidth for priority levels 0-7. Units are in
+bytes per second.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__priority','__te_bandwidth',)
+
+ _yang_name = 'unreserved-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'unreserved-bandwidth']
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/priority (uint8)
+
+ YANG Description: Priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ priority = __builtin__.property(_get_priority, _set_priority)
+ te_bandwidth = __builtin__.property(_get_te_bandwidth, _set_te_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('priority', priority), ('te_bandwidth', te_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..597c65903b26bc8cefae123a64988c0aa4c5cd2e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/unreserved-bandwidth/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'unreserved-bandwidth', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth, _set_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..602ca2e1a1aa0bd56135627dc9e3000869e09a9a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/unreserved-bandwidth/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'unreserved-bandwidth', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None), is_container='list', yang_name="odulist", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+
+ odulist = __builtin__.property(_get_odulist, _set_odulist)
+
+
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..94ca139a6b10008b227c4026e74a8f3cff14f421
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/te-link-attributes/unreserved-bandwidth/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'te-link-attributes', 'unreserved-bandwidth', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ odu_type = __builtin__.property(_get_odu_type, _set_odu_type)
+ number = __builtin__.property(_get_number, _set_number)
+ ts_number = __builtin__.property(_get_ts_number, _set_ts_number)
+
+
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/underlay/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/underlay/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8ac511c0723811b8f63497653bf430e23d9e083
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/link/te/underlay/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class underlay(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/link/te/underlay. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: State attributes for the TE link underlay.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__dynamic','__committed',)
+
+ _yang_name = 'underlay'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__dynamic = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="dynamic", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ self.__committed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="committed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'link', 'te', 'underlay']
+
+ def _get_dynamic(self):
+ """
+ Getter method for dynamic, mapped from YANG variable /networks/network/link/te/underlay/dynamic (boolean)
+
+ YANG Description: 'true' if the underlay is dynamically created.
+ """
+ return self.__dynamic
+
+ def _set_dynamic(self, v, load=False):
+ """
+ Setter method for dynamic, mapped from YANG variable /networks/network/link/te/underlay/dynamic (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_dynamic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_dynamic() directly.
+
+ YANG Description: 'true' if the underlay is dynamically created.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="dynamic", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """dynamic must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="dynamic", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)""",
+ })
+
+ self.__dynamic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_dynamic(self):
+ self.__dynamic = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="dynamic", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+
+ def _get_committed(self):
+ """
+ Getter method for committed, mapped from YANG variable /networks/network/link/te/underlay/committed (boolean)
+
+ YANG Description: 'true' if the underlay is committed.
+ """
+ return self.__committed
+
+ def _set_committed(self, v, load=False):
+ """
+ Setter method for committed, mapped from YANG variable /networks/network/link/te/underlay/committed (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_committed is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_committed() directly.
+
+ YANG Description: 'true' if the underlay is committed.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="committed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """committed must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="committed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)""",
+ })
+
+ self.__committed = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_committed(self):
+ self.__committed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="committed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+ dynamic = __builtin__.property(_get_dynamic)
+ committed = __builtin__.property(_get_committed)
+
+
+ _pyangbind_elements = OrderedDict([('dynamic', dynamic), ('committed', committed), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/network_types/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/network_types/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..75d12adce980c2efeaecc63888bfefa0d8a212f4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/network_types/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_topology
+class network_types(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/network-types. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Serves as an augmentation target.
+The network type is indicated through corresponding
+presence containers augmented into this container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_topology',)
+
+ _yang_name = 'network-types'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_topology = YANGDynClass(base=te_topology.te_topology, is_container='container', yang_name="te-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'network-types']
+
+ def _get_te_topology(self):
+ """
+ Getter method for te_topology, mapped from YANG variable /networks/network/network_types/te_topology (container)
+
+ YANG Description: Its presence identifies the TE topology type.
+ """
+ return self.__te_topology
+
+ def _set_te_topology(self, v, load=False):
+ """
+ Setter method for te_topology, mapped from YANG variable /networks/network/network_types/te_topology (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_topology is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_topology() directly.
+
+ YANG Description: Its presence identifies the TE topology type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_topology.te_topology, is_container='container', yang_name="te-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_topology must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_topology.te_topology, is_container='container', yang_name="te-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_topology = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_topology(self):
+ self.__te_topology = YANGDynClass(base=te_topology.te_topology, is_container='container', yang_name="te-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_topology = __builtin__.property(_get_te_topology, _set_te_topology)
+
+
+ _pyangbind_elements = OrderedDict([('te_topology', te_topology), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/network_types/te_topology/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/network_types/te_topology/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e986049c1a93b6aa60e414fb7a0127a46e2b2b9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/network_types/te_topology/__init__.py
@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class te_topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/network-types/te-topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Its presence identifies the TE topology type.
+ """
+ _pyangbind_elements = {}
+
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..11a24953959b6adc3fd494341b1e325c665e534c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/__init__.py
@@ -0,0 +1,291 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import supporting_node
+from . import termination_point
+from . import te
+class node(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The inventory of nodes of this network.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__supporting_node','__termination_point','__te_node_id','__te',)
+
+ _yang_name = 'node'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='node-id', is_config=True)
+ self.__supporting_node = YANGDynClass(base=YANGListType("network_ref node_ref",supporting_node.supporting_node, yang_name="supporting-node", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref node-ref', extensions=None), is_container='list', yang_name="supporting-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+ self.__termination_point = YANGDynClass(base=YANGListType("tp_id",termination_point.termination_point, yang_name="termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tp-id', extensions=None), is_container='list', yang_name="termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)
+ self.__te_node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="te-node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-node-id', is_config=True)
+ self.__te = YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/node_id (node-id)
+
+ YANG Description: Uniquely identifies a node within the containing
+network.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/node_id (node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: Uniquely identifies a node within the containing
+network.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with node-id""",
+ 'defined-type': "ietf-network:node-id",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='node-id', is_config=True)
+
+
+ def _get_supporting_node(self):
+ """
+ Getter method for supporting_node, mapped from YANG variable /networks/network/node/supporting_node (list)
+
+ YANG Description: Represents another node that is in an underlay network
+and that supports this node. Used to represent layering
+structure.
+ """
+ return self.__supporting_node
+
+ def _set_supporting_node(self, v, load=False):
+ """
+ Setter method for supporting_node, mapped from YANG variable /networks/network/node/supporting_node (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_supporting_node is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_supporting_node() directly.
+
+ YANG Description: Represents another node that is in an underlay network
+and that supports this node. Used to represent layering
+structure.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("network_ref node_ref",supporting_node.supporting_node, yang_name="supporting-node", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref node-ref', extensions=None), is_container='list', yang_name="supporting-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """supporting_node must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("network_ref node_ref",supporting_node.supporting_node, yang_name="supporting-node", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref node-ref', extensions=None), is_container='list', yang_name="supporting-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)""",
+ })
+
+ self.__supporting_node = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_supporting_node(self):
+ self.__supporting_node = YANGDynClass(base=YANGListType("network_ref node_ref",supporting_node.supporting_node, yang_name="supporting-node", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='network-ref node-ref', extensions=None), is_container='list', yang_name="supporting-node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='list', is_config=True)
+
+
+ def _get_termination_point(self):
+ """
+ Getter method for termination_point, mapped from YANG variable /networks/network/node/termination_point (list)
+
+ YANG Description: A termination point can terminate a link.
+Depending on the type of topology, a termination point
+could, for example, refer to a port or an interface.
+ """
+ return self.__termination_point
+
+ def _set_termination_point(self, v, load=False):
+ """
+ Setter method for termination_point, mapped from YANG variable /networks/network/node/termination_point (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_termination_point is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_termination_point() directly.
+
+ YANG Description: A termination point can terminate a link.
+Depending on the type of topology, a termination point
+could, for example, refer to a port or an interface.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tp_id",termination_point.termination_point, yang_name="termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tp-id', extensions=None), is_container='list', yang_name="termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """termination_point must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tp_id",termination_point.termination_point, yang_name="termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tp-id', extensions=None), is_container='list', yang_name="termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__termination_point = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_termination_point(self):
+ self.__termination_point = YANGDynClass(base=YANGListType("tp_id",termination_point.termination_point, yang_name="termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tp-id', extensions=None), is_container='list', yang_name="termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-network-topology', defining_module='ietf-network-topology', yang_type='list', is_config=True)
+
+
+ def _get_te_node_id(self):
+ """
+ Getter method for te_node_id, mapped from YANG variable /networks/network/node/te_node_id (te-types:te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+A node is specific to a topology to which it belongs.
+ """
+ return self.__te_node_id
+
+ def _set_te_node_id(self, v, load=False):
+ """
+ Setter method for te_node_id, mapped from YANG variable /networks/network/node/te_node_id (te-types:te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+A node is specific to a topology to which it belongs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="te-node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_node_id must be of a type compatible with te-types:te-node-id""",
+ 'defined-type': "te-types:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="te-node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-node-id', is_config=True)""",
+ })
+
+ self.__te_node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_node_id(self):
+ self.__te_node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="te-node-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-node-id', is_config=True)
+
+
+ def _get_te(self):
+ """
+ Getter method for te, mapped from YANG variable /networks/network/node/te (container)
+
+ YANG Description: Indicates TE support.
+ """
+ return self.__te
+
+ def _set_te(self, v, load=False):
+ """
+ Setter method for te, mapped from YANG variable /networks/network/node/te (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te() directly.
+
+ YANG Description: Indicates TE support.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te(self):
+ self.__te = YANGDynClass(base=te.te, is_container='container', yang_name="te", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ supporting_node = __builtin__.property(_get_supporting_node, _set_supporting_node)
+ termination_point = __builtin__.property(_get_termination_point, _set_termination_point)
+ te_node_id = __builtin__.property(_get_te_node_id, _set_te_node_id)
+ te = __builtin__.property(_get_te, _set_te)
+
+
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('supporting_node', supporting_node), ('termination_point', termination_point), ('te_node_id', te_node_id), ('te', te), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/supporting_node/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/supporting_node/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c4cd2fc8eb7a10aa682f77595b9ee0ba29765045
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/supporting_node/__init__.py
@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class supporting_node(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/supporting-node. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Represents another node that is in an underlay network
+and that supports this node. Used to represent layering
+structure.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref','__node_ref',)
+
+ _yang_name = 'supporting-node'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='leafref', is_config=True)
+ self.__node_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='leafref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'supporting-node']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/supporting_node/network_ref (leafref)
+
+ YANG Description: References the underlay network of which the
+underlay node is a part.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/supporting_node/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: References the underlay network of which the
+underlay node is a part.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='leafref', is_config=True)
+
+
+ def _get_node_ref(self):
+ """
+ Getter method for node_ref, mapped from YANG variable /networks/network/node/supporting_node/node_ref (leafref)
+
+ YANG Description: References the underlay node itself.
+ """
+ return self.__node_ref
+
+ def _set_node_ref(self, v, load=False):
+ """
+ Setter method for node_ref, mapped from YANG variable /networks/network/node/supporting_node/node_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_ref() directly.
+
+ YANG Description: References the underlay node itself.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__node_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_ref(self):
+ self.__node_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-network', defining_module='ietf-network', yang_type='leafref', is_config=True)
+
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ node_ref = __builtin__.property(_get_node_ref, _set_node_ref)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ('node_ref', node_ref), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..90adef961b80a55ee2c4a53e302ebef0d76218a7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/__init__.py
@@ -0,0 +1,519 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_node_attributes
+from . import geolocation
+from . import information_source_state
+from . import information_source_entry
+from . import statistics
+from . import tunnel_termination_point
+class te(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Indicates TE support.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_node_template','__te_node_attributes','__oper_status','__geolocation','__is_multi_access_dr','__information_source','__information_source_instance','__information_source_state','__information_source_entry','__statistics','__tunnel_termination_point',)
+
+ _yang_name = 'te'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_node_template = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="te-node-template", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__te_node_attributes = YANGDynClass(base=te_node_attributes.te_node_attributes, is_container='container', yang_name="te-node-attributes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__oper_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)
+ self.__geolocation = YANGDynClass(base=geolocation.geolocation, is_container='container', yang_name="geolocation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__is_multi_access_dr = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-multi-access-dr", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)
+ self.__information_source = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+ self.__information_source_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__information_source_state = YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__information_source_entry = YANGDynClass(base=YANGListType("information_source information_source_instance",information_source_entry.information_source_entry, yang_name="information-source-entry", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='information-source information-source-instance', extensions=None), is_container='list', yang_name="information-source-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__statistics = YANGDynClass(base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__tunnel_termination_point = YANGDynClass(base=YANGListType("tunnel_tp_id",tunnel_termination_point.tunnel_termination_point, yang_name="tunnel-termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-tp-id', extensions=None), is_container='list', yang_name="tunnel-termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te']
+
+ def _get_te_node_template(self):
+ """
+ Getter method for te_node_template, mapped from YANG variable /networks/network/node/te/te_node_template (leafref)
+
+ YANG Description: The reference to a TE node template.
+ """
+ return self.__te_node_template
+
+ def _set_te_node_template(self, v, load=False):
+ """
+ Setter method for te_node_template, mapped from YANG variable /networks/network/node/te/te_node_template (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_node_template is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_node_template() directly.
+
+ YANG Description: The reference to a TE node template.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="te-node-template", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_node_template must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="te-node-template", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__te_node_template = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_node_template(self):
+ self.__te_node_template = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="te-node-template", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_te_node_attributes(self):
+ """
+ Getter method for te_node_attributes, mapped from YANG variable /networks/network/node/te/te_node_attributes (container)
+
+ YANG Description: Contains node attributes in a TE topology.
+ """
+ return self.__te_node_attributes
+
+ def _set_te_node_attributes(self, v, load=False):
+ """
+ Setter method for te_node_attributes, mapped from YANG variable /networks/network/node/te/te_node_attributes (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_node_attributes is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_node_attributes() directly.
+
+ YANG Description: Contains node attributes in a TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_node_attributes.te_node_attributes, is_container='container', yang_name="te-node-attributes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_node_attributes must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_node_attributes.te_node_attributes, is_container='container', yang_name="te-node-attributes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_node_attributes = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_node_attributes(self):
+ self.__te_node_attributes = YANGDynClass(base=te_node_attributes.te_node_attributes, is_container='container', yang_name="te-node-attributes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_oper_status(self):
+ """
+ Getter method for oper_status, mapped from YANG variable /networks/network/node/te/oper_status (te-types:te-oper-status)
+
+ YANG Description: The current operational state of the node.
+ """
+ return self.__oper_status
+
+ def _set_oper_status(self, v, load=False):
+ """
+ Setter method for oper_status, mapped from YANG variable /networks/network/node/te/oper_status (te-types:te-oper-status)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_oper_status is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_oper_status() directly.
+
+ YANG Description: The current operational state of the node.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """oper_status must be of a type compatible with te-types:te-oper-status""",
+ 'defined-type': "te-types:te-oper-status",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)""",
+ })
+
+ self.__oper_status = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_oper_status(self):
+ self.__oper_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)
+
+
+ def _get_geolocation(self):
+ """
+ Getter method for geolocation, mapped from YANG variable /networks/network/node/te/geolocation (container)
+
+ YANG Description: Contains a GPS location.
+ """
+ return self.__geolocation
+
+ def _set_geolocation(self, v, load=False):
+ """
+ Setter method for geolocation, mapped from YANG variable /networks/network/node/te/geolocation (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_geolocation is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_geolocation() directly.
+
+ YANG Description: Contains a GPS location.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=geolocation.geolocation, is_container='container', yang_name="geolocation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """geolocation must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=geolocation.geolocation, is_container='container', yang_name="geolocation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__geolocation = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_geolocation(self):
+ self.__geolocation = YANGDynClass(base=geolocation.geolocation, is_container='container', yang_name="geolocation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_is_multi_access_dr(self):
+ """
+ Getter method for is_multi_access_dr, mapped from YANG variable /networks/network/node/te/is_multi_access_dr (empty)
+
+ YANG Description: The presence of this attribute indicates that this TE node
+is a pseudonode elected as a designated router.
+ """
+ return self.__is_multi_access_dr
+
+ def _set_is_multi_access_dr(self, v, load=False):
+ """
+ Setter method for is_multi_access_dr, mapped from YANG variable /networks/network/node/te/is_multi_access_dr (empty)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_multi_access_dr is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_multi_access_dr() directly.
+
+ YANG Description: The presence of this attribute indicates that this TE node
+is a pseudonode elected as a designated router.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-multi-access-dr", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_multi_access_dr must be of a type compatible with empty""",
+ 'defined-type': "empty",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-multi-access-dr", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)""",
+ })
+
+ self.__is_multi_access_dr = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_multi_access_dr(self):
+ self.__is_multi_access_dr = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-multi-access-dr", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)
+
+
+ def _get_information_source(self):
+ """
+ Getter method for information_source, mapped from YANG variable /networks/network/node/te/information_source (te-info-source)
+
+ YANG Description: Indicates the type of information source.
+ """
+ return self.__information_source
+
+ def _set_information_source(self, v, load=False):
+ """
+ Setter method for information_source, mapped from YANG variable /networks/network/node/te/information_source (te-info-source)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source() directly.
+
+ YANG Description: Indicates the type of information source.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source must be of a type compatible with te-info-source""",
+ 'defined-type': "ietf-te-topology:te-info-source",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)""",
+ })
+
+ self.__information_source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source(self):
+ self.__information_source = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+
+
+ def _get_information_source_instance(self):
+ """
+ Getter method for information_source_instance, mapped from YANG variable /networks/network/node/te/information_source_instance (string)
+
+ YANG Description: The name indicating the instance of the information
+source.
+ """
+ return self.__information_source_instance
+
+ def _set_information_source_instance(self, v, load=False):
+ """
+ Setter method for information_source_instance, mapped from YANG variable /networks/network/node/te/information_source_instance (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source_instance is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source_instance() directly.
+
+ YANG Description: The name indicating the instance of the information
+source.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source_instance must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__information_source_instance = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source_instance(self):
+ self.__information_source_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_information_source_state(self):
+ """
+ Getter method for information_source_state, mapped from YANG variable /networks/network/node/te/information_source_state (container)
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ return self.__information_source_state
+
+ def _set_information_source_state(self, v, load=False):
+ """
+ Setter method for information_source_state, mapped from YANG variable /networks/network/node/te/information_source_state (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source_state is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source_state() directly.
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source_state must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__information_source_state = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source_state(self):
+ self.__information_source_state = YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_information_source_entry(self):
+ """
+ Getter method for information_source_entry, mapped from YANG variable /networks/network/node/te/information_source_entry (list)
+
+ YANG Description: A list of information sources learned, including the source
+that is used.
+ """
+ return self.__information_source_entry
+
+ def _set_information_source_entry(self, v, load=False):
+ """
+ Setter method for information_source_entry, mapped from YANG variable /networks/network/node/te/information_source_entry (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source_entry is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source_entry() directly.
+
+ YANG Description: A list of information sources learned, including the source
+that is used.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("information_source information_source_instance",information_source_entry.information_source_entry, yang_name="information-source-entry", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='information-source information-source-instance', extensions=None), is_container='list', yang_name="information-source-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source_entry must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("information_source information_source_instance",information_source_entry.information_source_entry, yang_name="information-source-entry", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='information-source information-source-instance', extensions=None), is_container='list', yang_name="information-source-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__information_source_entry = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source_entry(self):
+ self.__information_source_entry = YANGDynClass(base=YANGListType("information_source information_source_instance",information_source_entry.information_source_entry, yang_name="information-source-entry", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='information-source information-source-instance', extensions=None), is_container='list', yang_name="information-source-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_statistics(self):
+ """
+ Getter method for statistics, mapped from YANG variable /networks/network/node/te/statistics (container)
+
+ YANG Description: Statistics data.
+ """
+ return self.__statistics
+
+ def _set_statistics(self, v, load=False):
+ """
+ Setter method for statistics, mapped from YANG variable /networks/network/node/te/statistics (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_statistics is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_statistics() directly.
+
+ YANG Description: Statistics data.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """statistics must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__statistics = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_statistics(self):
+ self.__statistics = YANGDynClass(base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_tunnel_termination_point(self):
+ """
+ Getter method for tunnel_termination_point, mapped from YANG variable /networks/network/node/te/tunnel_termination_point (list)
+
+ YANG Description: A termination point can terminate a tunnel.
+ """
+ return self.__tunnel_termination_point
+
+ def _set_tunnel_termination_point(self, v, load=False):
+ """
+ Setter method for tunnel_termination_point, mapped from YANG variable /networks/network/node/te/tunnel_termination_point (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_termination_point is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_termination_point() directly.
+
+ YANG Description: A termination point can terminate a tunnel.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tunnel_tp_id",tunnel_termination_point.tunnel_termination_point, yang_name="tunnel-termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-tp-id', extensions=None), is_container='list', yang_name="tunnel-termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_termination_point must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tunnel_tp_id",tunnel_termination_point.tunnel_termination_point, yang_name="tunnel-termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-tp-id', extensions=None), is_container='list', yang_name="tunnel-termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__tunnel_termination_point = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_termination_point(self):
+ self.__tunnel_termination_point = YANGDynClass(base=YANGListType("tunnel_tp_id",tunnel_termination_point.tunnel_termination_point, yang_name="tunnel-termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-tp-id', extensions=None), is_container='list', yang_name="tunnel-termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ te_node_template = __builtin__.property(_get_te_node_template, _set_te_node_template)
+ te_node_attributes = __builtin__.property(_get_te_node_attributes, _set_te_node_attributes)
+ oper_status = __builtin__.property(_get_oper_status)
+ geolocation = __builtin__.property(_get_geolocation)
+ is_multi_access_dr = __builtin__.property(_get_is_multi_access_dr)
+ information_source = __builtin__.property(_get_information_source)
+ information_source_instance = __builtin__.property(_get_information_source_instance)
+ information_source_state = __builtin__.property(_get_information_source_state)
+ information_source_entry = __builtin__.property(_get_information_source_entry)
+ statistics = __builtin__.property(_get_statistics)
+ tunnel_termination_point = __builtin__.property(_get_tunnel_termination_point, _set_tunnel_termination_point)
+
+
+ _pyangbind_elements = OrderedDict([('te_node_template', te_node_template), ('te_node_attributes', te_node_attributes), ('oper_status', oper_status), ('geolocation', geolocation), ('is_multi_access_dr', is_multi_access_dr), ('information_source', information_source), ('information_source_instance', information_source_instance), ('information_source_state', information_source_state), ('information_source_entry', information_source_entry), ('statistics', statistics), ('tunnel_termination_point', tunnel_termination_point), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/geolocation/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/geolocation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9e405188bb0b9a5ca59a72e70cf39a1a47338f8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/geolocation/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class geolocation(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/geolocation. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains a GPS location.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__altitude','__latitude','__longitude',)
+
+ _yang_name = 'geolocation'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__altitude = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-9223372036854775808..9223372036854775807']}, int_size=64), is_leaf=True, yang_name="altitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int64', is_config=False)
+ self.__latitude = YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-90..90']}), is_leaf=True, yang_name="latitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+ self.__longitude = YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-180..180']}), is_leaf=True, yang_name="longitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'geolocation']
+
+ def _get_altitude(self):
+ """
+ Getter method for altitude, mapped from YANG variable /networks/network/node/te/geolocation/altitude (int64)
+
+ YANG Description: Distance above sea level.
+ """
+ return self.__altitude
+
+ def _set_altitude(self, v, load=False):
+ """
+ Setter method for altitude, mapped from YANG variable /networks/network/node/te/geolocation/altitude (int64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_altitude is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_altitude() directly.
+
+ YANG Description: Distance above sea level.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-9223372036854775808..9223372036854775807']}, int_size=64), is_leaf=True, yang_name="altitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """altitude must be of a type compatible with int64""",
+ 'defined-type': "int64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-9223372036854775808..9223372036854775807']}, int_size=64), is_leaf=True, yang_name="altitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int64', is_config=False)""",
+ })
+
+ self.__altitude = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_altitude(self):
+ self.__altitude = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-9223372036854775808..9223372036854775807']}, int_size=64), is_leaf=True, yang_name="altitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int64', is_config=False)
+
+
+ def _get_latitude(self):
+ """
+ Getter method for latitude, mapped from YANG variable /networks/network/node/te/geolocation/latitude (geographic-coordinate-degree)
+
+ YANG Description: Relative position north or south on the Earth's surface.
+ """
+ return self.__latitude
+
+ def _set_latitude(self, v, load=False):
+ """
+ Setter method for latitude, mapped from YANG variable /networks/network/node/te/geolocation/latitude (geographic-coordinate-degree)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_latitude is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_latitude() directly.
+
+ YANG Description: Relative position north or south on the Earth's surface.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-90..90']}), is_leaf=True, yang_name="latitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """latitude must be of a type compatible with geographic-coordinate-degree""",
+ 'defined-type': "ietf-te-topology:geographic-coordinate-degree",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-90..90']}), is_leaf=True, yang_name="latitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)""",
+ })
+
+ self.__latitude = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_latitude(self):
+ self.__latitude = YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-90..90']}), is_leaf=True, yang_name="latitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+
+
+ def _get_longitude(self):
+ """
+ Getter method for longitude, mapped from YANG variable /networks/network/node/te/geolocation/longitude (geographic-coordinate-degree)
+
+ YANG Description: Angular distance east or west on the Earth's surface.
+ """
+ return self.__longitude
+
+ def _set_longitude(self, v, load=False):
+ """
+ Setter method for longitude, mapped from YANG variable /networks/network/node/te/geolocation/longitude (geographic-coordinate-degree)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_longitude is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_longitude() directly.
+
+ YANG Description: Angular distance east or west on the Earth's surface.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-180..180']}), is_leaf=True, yang_name="longitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """longitude must be of a type compatible with geographic-coordinate-degree""",
+ 'defined-type': "ietf-te-topology:geographic-coordinate-degree",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-180..180']}), is_leaf=True, yang_name="longitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)""",
+ })
+
+ self.__longitude = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_longitude(self):
+ self.__longitude = YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-180..180']}), is_leaf=True, yang_name="longitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+
+ altitude = __builtin__.property(_get_altitude)
+ latitude = __builtin__.property(_get_latitude)
+ longitude = __builtin__.property(_get_longitude)
+
+
+ _pyangbind_elements = OrderedDict([('altitude', altitude), ('latitude', latitude), ('longitude', longitude), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e51769ff90cb32cf778bdfc427c8646cf214dc7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/__init__.py
@@ -0,0 +1,451 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import information_source_state
+from . import connectivity_matrices
+from . import underlay_topology
+class information_source_entry(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of information sources learned, including the source
+that is used.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__information_source','__information_source_instance','__information_source_state','__connectivity_matrices','__domain_id','__is_abstract','__name','__signaling_address','__underlay_topology',)
+
+ _yang_name = 'information-source-entry'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__information_source = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+ self.__information_source_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__information_source_state = YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__connectivity_matrices = YANGDynClass(base=connectivity_matrices.connectivity_matrices, is_container='container', yang_name="connectivity-matrices", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__domain_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="domain-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__is_abstract = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__signaling_address = YANGDynClass(unique=True, base=TypedListType(allowed_type=[RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),]), is_leaf=False, yang_name="signaling-address", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:ip-address', is_config=False)
+ self.__underlay_topology = YANGDynClass(base=underlay_topology.underlay_topology, is_container='container', yang_name="underlay-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry']
+
+ def _get_information_source(self):
+ """
+ Getter method for information_source, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source (te-info-source)
+
+ YANG Description: Indicates the type of information source.
+ """
+ return self.__information_source
+
+ def _set_information_source(self, v, load=False):
+ """
+ Setter method for information_source, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source (te-info-source)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source() directly.
+
+ YANG Description: Indicates the type of information source.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source must be of a type compatible with te-info-source""",
+ 'defined-type': "ietf-te-topology:te-info-source",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)""",
+ })
+
+ self.__information_source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source(self):
+ self.__information_source = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'unknown': {}, 'locally-configured': {}, 'ospfv2': {}, 'ospfv3': {}, 'isis': {}, 'bgp-ls': {}, 'system-processed': {}, 'other': {}},), is_leaf=True, yang_name="information-source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-info-source', is_config=False)
+
+
+ def _get_information_source_instance(self):
+ """
+ Getter method for information_source_instance, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_instance (string)
+
+ YANG Description: The name indicating the instance of the information
+source.
+ """
+ return self.__information_source_instance
+
+ def _set_information_source_instance(self, v, load=False):
+ """
+ Setter method for information_source_instance, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_instance (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source_instance is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source_instance() directly.
+
+ YANG Description: The name indicating the instance of the information
+source.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source_instance must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__information_source_instance = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source_instance(self):
+ self.__information_source_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="information-source-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_information_source_state(self):
+ """
+ Getter method for information_source_state, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state (container)
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ return self.__information_source_state
+
+ def _set_information_source_state(self, v, load=False):
+ """
+ Setter method for information_source_state, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_information_source_state is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_information_source_state() directly.
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """information_source_state must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__information_source_state = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_information_source_state(self):
+ self.__information_source_state = YANGDynClass(base=information_source_state.information_source_state, is_container='container', yang_name="information-source-state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_connectivity_matrices(self):
+ """
+ Getter method for connectivity_matrices, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices (container)
+
+ YANG Description: Contains a connectivity matrix on a TE node.
+ """
+ return self.__connectivity_matrices
+
+ def _set_connectivity_matrices(self, v, load=False):
+ """
+ Setter method for connectivity_matrices, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_connectivity_matrices is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_connectivity_matrices() directly.
+
+ YANG Description: Contains a connectivity matrix on a TE node.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=connectivity_matrices.connectivity_matrices, is_container='container', yang_name="connectivity-matrices", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """connectivity_matrices must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=connectivity_matrices.connectivity_matrices, is_container='container', yang_name="connectivity-matrices", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__connectivity_matrices = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_connectivity_matrices(self):
+ self.__connectivity_matrices = YANGDynClass(base=connectivity_matrices.connectivity_matrices, is_container='container', yang_name="connectivity-matrices", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_domain_id(self):
+ """
+ Getter method for domain_id, mapped from YANG variable /networks/network/node/te/information_source_entry/domain_id (uint32)
+
+ YANG Description: Identifies the domain to which this node belongs.
+This attribute is used to support inter-domain links.
+ """
+ return self.__domain_id
+
+ def _set_domain_id(self, v, load=False):
+ """
+ Setter method for domain_id, mapped from YANG variable /networks/network/node/te/information_source_entry/domain_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_domain_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_domain_id() directly.
+
+ YANG Description: Identifies the domain to which this node belongs.
+This attribute is used to support inter-domain links.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="domain-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """domain_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="domain-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__domain_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_domain_id(self):
+ self.__domain_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="domain-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_is_abstract(self):
+ """
+ Getter method for is_abstract, mapped from YANG variable /networks/network/node/te/information_source_entry/is_abstract (empty)
+
+ YANG Description: Present if the node is abstract; not present if the node
+is actual.
+ """
+ return self.__is_abstract
+
+ def _set_is_abstract(self, v, load=False):
+ """
+ Setter method for is_abstract, mapped from YANG variable /networks/network/node/te/information_source_entry/is_abstract (empty)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_abstract is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_abstract() directly.
+
+ YANG Description: Present if the node is abstract; not present if the node
+is actual.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_abstract must be of a type compatible with empty""",
+ 'defined-type': "empty",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)""",
+ })
+
+ self.__is_abstract = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_abstract(self):
+ self.__is_abstract = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=False)
+
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/information_source_entry/name (string)
+
+ YANG Description: Node name.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/information_source_entry/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Node name.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_signaling_address(self):
+ """
+ Getter method for signaling_address, mapped from YANG variable /networks/network/node/te/information_source_entry/signaling_address (inet:ip-address)
+
+ YANG Description: The node's signaling address.
+ """
+ return self.__signaling_address
+
+ def _set_signaling_address(self, v, load=False):
+ """
+ Setter method for signaling_address, mapped from YANG variable /networks/network/node/te/information_source_entry/signaling_address (inet:ip-address)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_signaling_address is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_signaling_address() directly.
+
+ YANG Description: The node's signaling address.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=[RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),]), is_leaf=False, yang_name="signaling-address", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:ip-address', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """signaling_address must be of a type compatible with inet:ip-address""",
+ 'defined-type': "inet:ip-address",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=[RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),]), is_leaf=False, yang_name="signaling-address", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:ip-address', is_config=False)""",
+ })
+
+ self.__signaling_address = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_signaling_address(self):
+ self.__signaling_address = YANGDynClass(unique=True, base=TypedListType(allowed_type=[RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),]), is_leaf=False, yang_name="signaling-address", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:ip-address', is_config=False)
+
+
+ def _get_underlay_topology(self):
+ """
+ Getter method for underlay_topology, mapped from YANG variable /networks/network/node/te/information_source_entry/underlay_topology (container)
+
+ YANG Description: When an abstract node encapsulates a topology, the
+attributes in this container point to said topology.
+ """
+ return self.__underlay_topology
+
+ def _set_underlay_topology(self, v, load=False):
+ """
+ Setter method for underlay_topology, mapped from YANG variable /networks/network/node/te/information_source_entry/underlay_topology (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_underlay_topology is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_underlay_topology() directly.
+
+ YANG Description: When an abstract node encapsulates a topology, the
+attributes in this container point to said topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=underlay_topology.underlay_topology, is_container='container', yang_name="underlay-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """underlay_topology must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=underlay_topology.underlay_topology, is_container='container', yang_name="underlay-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__underlay_topology = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_underlay_topology(self):
+ self.__underlay_topology = YANGDynClass(base=underlay_topology.underlay_topology, is_container='container', yang_name="underlay-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ information_source = __builtin__.property(_get_information_source)
+ information_source_instance = __builtin__.property(_get_information_source_instance)
+ information_source_state = __builtin__.property(_get_information_source_state)
+ connectivity_matrices = __builtin__.property(_get_connectivity_matrices)
+ domain_id = __builtin__.property(_get_domain_id)
+ is_abstract = __builtin__.property(_get_is_abstract)
+ name = __builtin__.property(_get_name)
+ signaling_address = __builtin__.property(_get_signaling_address)
+ underlay_topology = __builtin__.property(_get_underlay_topology)
+
+
+ _pyangbind_elements = OrderedDict([('information_source', information_source), ('information_source_instance', information_source_instance), ('information_source_state', information_source_state), ('connectivity_matrices', connectivity_matrices), ('domain_id', domain_id), ('is_abstract', is_abstract), ('name', name), ('signaling_address', signaling_address), ('underlay_topology', underlay_topology), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a773758ba44ded62fa976a1b512ca27ca0ac49bb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/__init__.py
@@ -0,0 +1,412 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restrictions
+from . import underlay
+from . import path_constraints
+from . import optimizations
+from . import path_properties
+from . import connectivity_matrix
+class connectivity_matrices(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains a connectivity matrix on a TE node.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__number_of_entries','__label_restrictions','__is_allowed','__underlay','__path_constraints','__optimizations','__path_properties','__connectivity_matrix',)
+
+ _yang_name = 'connectivity-matrices'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__number_of_entries = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__connectivity_matrix = YANGDynClass(base=YANGListType("id",connectivity_matrix.connectivity_matrix, yang_name="connectivity-matrix", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='id', extensions=None), is_container='list', yang_name="connectivity-matrix", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices']
+
+ def _get_number_of_entries(self):
+ """
+ Getter method for number_of_entries, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/number_of_entries (uint16)
+
+ YANG Description: The number of connectivity matrix entries.
+If this number is specified in the configuration request,
+the number is the requested number of entries, which may
+not all be listed in the list;
+if this number is reported in the state data,
+the number is the current number of operational entries.
+ """
+ return self.__number_of_entries
+
+ def _set_number_of_entries(self, v, load=False):
+ """
+ Setter method for number_of_entries, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/number_of_entries (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number_of_entries is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number_of_entries() directly.
+
+ YANG Description: The number of connectivity matrix entries.
+If this number is specified in the configuration request,
+the number is the requested number of entries, which may
+not all be listed in the list;
+if this number is reported in the state data,
+the number is the current number of operational entries.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number_of_entries must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__number_of_entries = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number_of_entries(self):
+ self.__number_of_entries = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+
+
+ def _get_label_restrictions(self):
+ """
+ Getter method for label_restrictions, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions (container)
+
+ YANG Description: The label restrictions container.
+ """
+ return self.__label_restrictions
+
+ def _set_label_restrictions(self, v, load=False):
+ """
+ Setter method for label_restrictions, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restrictions is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restrictions() directly.
+
+ YANG Description: The label restrictions container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restrictions must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_restrictions = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restrictions(self):
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_is_allowed(self):
+ """
+ Getter method for is_allowed, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/is_allowed (boolean)
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ return self.__is_allowed
+
+ def _set_is_allowed(self, v, load=False):
+ """
+ Setter method for is_allowed, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/is_allowed (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_allowed is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_allowed() directly.
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_allowed must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)""",
+ })
+
+ self.__is_allowed = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_allowed(self):
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+
+ def _get_underlay(self):
+ """
+ Getter method for underlay, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay (container)
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ return self.__underlay
+
+ def _set_underlay(self, v, load=False):
+ """
+ Setter method for underlay, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_underlay is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_underlay() directly.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """underlay must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__underlay = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_underlay(self):
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_constraints(self):
+ """
+ Getter method for path_constraints, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints (container)
+
+ YANG Description: TE named path constraints container.
+ """
+ return self.__path_constraints
+
+ def _set_path_constraints(self, v, load=False):
+ """
+ Setter method for path_constraints, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_constraints is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_constraints() directly.
+
+ YANG Description: TE named path constraints container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_constraints must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_constraints = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_constraints(self):
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_optimizations(self):
+ """
+ Getter method for optimizations, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__optimizations
+
+ def _set_optimizations(self, v, load=False):
+ """
+ Setter method for optimizations, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimizations is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimizations() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimizations must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__optimizations = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimizations(self):
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_properties(self):
+ """
+ Getter method for path_properties, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties (container)
+
+ YANG Description: The TE path properties.
+ """
+ return self.__path_properties
+
+ def _set_path_properties(self, v, load=False):
+ """
+ Setter method for path_properties, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_properties is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_properties() directly.
+
+ YANG Description: The TE path properties.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_properties must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_properties = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_properties(self):
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_connectivity_matrix(self):
+ """
+ Getter method for connectivity_matrix, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix (list)
+
+ YANG Description: Represents a node's switching limitations, i.e.,
+limitations in the interconnecting network TE links
+across the node.
+ """
+ return self.__connectivity_matrix
+
+ def _set_connectivity_matrix(self, v, load=False):
+ """
+ Setter method for connectivity_matrix, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_connectivity_matrix is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_connectivity_matrix() directly.
+
+ YANG Description: Represents a node's switching limitations, i.e.,
+limitations in the interconnecting network TE links
+across the node.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("id",connectivity_matrix.connectivity_matrix, yang_name="connectivity-matrix", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='id', extensions=None), is_container='list', yang_name="connectivity-matrix", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """connectivity_matrix must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("id",connectivity_matrix.connectivity_matrix, yang_name="connectivity-matrix", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='id', extensions=None), is_container='list', yang_name="connectivity-matrix", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__connectivity_matrix = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_connectivity_matrix(self):
+ self.__connectivity_matrix = YANGDynClass(base=YANGListType("id",connectivity_matrix.connectivity_matrix, yang_name="connectivity-matrix", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='id', extensions=None), is_container='list', yang_name="connectivity-matrix", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ number_of_entries = __builtin__.property(_get_number_of_entries)
+ label_restrictions = __builtin__.property(_get_label_restrictions)
+ is_allowed = __builtin__.property(_get_is_allowed)
+ underlay = __builtin__.property(_get_underlay)
+ path_constraints = __builtin__.property(_get_path_constraints)
+ optimizations = __builtin__.property(_get_optimizations)
+ path_properties = __builtin__.property(_get_path_properties)
+ connectivity_matrix = __builtin__.property(_get_connectivity_matrix)
+
+
+ _pyangbind_elements = OrderedDict([('number_of_entries', number_of_entries), ('label_restrictions', label_restrictions), ('is_allowed', is_allowed), ('underlay', underlay), ('path_constraints', path_constraints), ('optimizations', optimizations), ('path_properties', path_properties), ('connectivity_matrix', connectivity_matrix), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..edc6885b375fde570c5fc0ea5a921e49f04146da
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/__init__.py
@@ -0,0 +1,405 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import from_
+from . import to
+from . import underlay
+from . import path_constraints
+from . import optimizations
+from . import path_properties
+class connectivity_matrix(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Represents a node's switching limitations, i.e.,
+limitations in the interconnecting network TE links
+across the node.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__id','__from_','__to','__is_allowed','__underlay','__path_constraints','__optimizations','__path_properties',)
+
+ _yang_name = 'connectivity-matrix'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__from_ = YANGDynClass(base=from_.from_, is_container='container', yang_name="from", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__to = YANGDynClass(base=to.to, is_container='container', yang_name="to", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix']
+
+ def _get_id(self):
+ """
+ Getter method for id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/id (uint32)
+
+ YANG Description: Identifies the connectivity matrix entry.
+ """
+ return self.__id
+
+ def _set_id(self, v, load=False):
+ """
+ Setter method for id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_id() directly.
+
+ YANG Description: Identifies the connectivity matrix entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_id(self):
+ self.__id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_from_(self):
+ """
+ Getter method for from_, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from (container)
+
+ YANG Description: Reference to a source LTP.
+ """
+ return self.__from_
+
+ def _set_from_(self, v, load=False):
+ """
+ Setter method for from_, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_from_ is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_from_() directly.
+
+ YANG Description: Reference to a source LTP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=from_.from_, is_container='container', yang_name="from", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """from_ must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=from_.from_, is_container='container', yang_name="from", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__from_ = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_from_(self):
+ self.__from_ = YANGDynClass(base=from_.from_, is_container='container', yang_name="from", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_to(self):
+ """
+ Getter method for to, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to (container)
+
+ YANG Description: Reference to a destination LTP.
+ """
+ return self.__to
+
+ def _set_to(self, v, load=False):
+ """
+ Setter method for to, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_to is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_to() directly.
+
+ YANG Description: Reference to a destination LTP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=to.to, is_container='container', yang_name="to", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """to must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=to.to, is_container='container', yang_name="to", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__to = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_to(self):
+ self.__to = YANGDynClass(base=to.to, is_container='container', yang_name="to", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_is_allowed(self):
+ """
+ Getter method for is_allowed, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/is_allowed (boolean)
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ return self.__is_allowed
+
+ def _set_is_allowed(self, v, load=False):
+ """
+ Setter method for is_allowed, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/is_allowed (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_allowed is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_allowed() directly.
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_allowed must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)""",
+ })
+
+ self.__is_allowed = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_allowed(self):
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+
+ def _get_underlay(self):
+ """
+ Getter method for underlay, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay (container)
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ return self.__underlay
+
+ def _set_underlay(self, v, load=False):
+ """
+ Setter method for underlay, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_underlay is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_underlay() directly.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """underlay must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__underlay = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_underlay(self):
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_constraints(self):
+ """
+ Getter method for path_constraints, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints (container)
+
+ YANG Description: TE named path constraints container.
+ """
+ return self.__path_constraints
+
+ def _set_path_constraints(self, v, load=False):
+ """
+ Setter method for path_constraints, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_constraints is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_constraints() directly.
+
+ YANG Description: TE named path constraints container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_constraints must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_constraints = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_constraints(self):
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_optimizations(self):
+ """
+ Getter method for optimizations, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__optimizations
+
+ def _set_optimizations(self, v, load=False):
+ """
+ Setter method for optimizations, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimizations is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimizations() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimizations must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__optimizations = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimizations(self):
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_properties(self):
+ """
+ Getter method for path_properties, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties (container)
+
+ YANG Description: The TE path properties.
+ """
+ return self.__path_properties
+
+ def _set_path_properties(self, v, load=False):
+ """
+ Setter method for path_properties, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_properties is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_properties() directly.
+
+ YANG Description: The TE path properties.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_properties must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_properties = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_properties(self):
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ id = __builtin__.property(_get_id)
+ from_ = __builtin__.property(_get_from_)
+ to = __builtin__.property(_get_to)
+ is_allowed = __builtin__.property(_get_is_allowed)
+ underlay = __builtin__.property(_get_underlay)
+ path_constraints = __builtin__.property(_get_path_constraints)
+ optimizations = __builtin__.property(_get_optimizations)
+ path_properties = __builtin__.property(_get_path_properties)
+
+
+ _pyangbind_elements = OrderedDict([('id', id), ('from_', from_), ('to', to), ('is_allowed', is_allowed), ('underlay', underlay), ('path_constraints', path_constraints), ('optimizations', optimizations), ('path_properties', path_properties), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8769c9ff833e1692ef73c35baa17a41698f52311
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/__init__.py
@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restrictions
+class from_(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Reference to a source LTP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tp_ref','__label_restrictions',)
+
+ _yang_name = 'from'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from']
+
+ def _get_tp_ref(self):
+ """
+ Getter method for tp_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/tp_ref (leafref)
+
+ YANG Description: Relative reference to a termination point.
+ """
+ return self.__tp_ref
+
+ def _set_tp_ref(self, v, load=False):
+ """
+ Setter method for tp_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/tp_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tp_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tp_ref() directly.
+
+ YANG Description: Relative reference to a termination point.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tp_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__tp_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tp_ref(self):
+ self.__tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+
+ def _get_label_restrictions(self):
+ """
+ Getter method for label_restrictions, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions (container)
+
+ YANG Description: The label restrictions container.
+ """
+ return self.__label_restrictions
+
+ def _set_label_restrictions(self, v, load=False):
+ """
+ Setter method for label_restrictions, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restrictions is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restrictions() directly.
+
+ YANG Description: The label restrictions container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restrictions must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_restrictions = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restrictions(self):
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ tp_ref = __builtin__.property(_get_tp_ref)
+ label_restrictions = __builtin__.property(_get_label_restrictions)
+
+
+ _pyangbind_elements = OrderedDict([('tp_ref', tp_ref), ('label_restrictions', label_restrictions), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..90df40ae35535e21096173e6b5ef0176bbc231e4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restriction
+class label_restrictions(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The label restrictions container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__label_restriction',)
+
+ _yang_name = 'label-restrictions'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions']
+
+ def _get_label_restriction(self):
+ """
+ Getter method for label_restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction (list)
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ return self.__label_restriction
+
+ def _set_label_restriction(self, v, load=False):
+ """
+ Setter method for label_restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restriction() directly.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restriction must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__label_restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restriction(self):
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ label_restriction = __builtin__.property(_get_label_restriction)
+
+
+ _pyangbind_elements = OrderedDict([('label_restriction', label_restriction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..325db171092d6188d67e021e75e86b189b8ecc19
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/__init__.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_start
+from . import label_end
+from . import label_step
+from . import otn_label_range
+from . import ethernet_label_range
+class label_restriction(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restriction','__index','__label_start','__label_end','__label_step','__range_bitmap','__otn_label_range','__ethernet_label_range',)
+
+ _yang_name = 'label-restriction'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction']
+
+ def _get_restriction(self):
+ """
+ Getter method for restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/restriction (enumeration)
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ return self.__restriction
+
+ def _set_restriction(self, v, load=False):
+ """
+ Setter method for restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/restriction (enumeration)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restriction() directly.
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restriction must be of a type compatible with enumeration""",
+ 'defined-type': "ietf-te-topology:enumeration",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)""",
+ })
+
+ self.__restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restriction(self):
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/index (uint32)
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_label_start(self):
+ """
+ Getter method for label_start, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start (container)
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ return self.__label_start
+
+ def _set_label_start(self, v, load=False):
+ """
+ Setter method for label_start, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_start is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_start() directly.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_start must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_start = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_start(self):
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_end(self):
+ """
+ Getter method for label_end, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end (container)
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ return self.__label_end
+
+ def _set_label_end(self, v, load=False):
+ """
+ Setter method for label_end, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_end is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_end() directly.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_end must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_end = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_end(self):
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_step(self):
+ """
+ Getter method for label_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step (container)
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ return self.__label_step
+
+ def _set_label_step(self, v, load=False):
+ """
+ Setter method for label_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_step() directly.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_step must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_step(self):
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_range_bitmap(self):
+ """
+ Getter method for range_bitmap, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ return self.__range_bitmap
+
+ def _set_range_bitmap(self, v, load=False):
+ """
+ Setter method for range_bitmap, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_bitmap is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_bitmap() directly.
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_bitmap must be of a type compatible with yang:hex-string""",
+ 'defined-type': "yang:hex-string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)""",
+ })
+
+ self.__range_bitmap = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_bitmap(self):
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+
+
+ def _get_otn_label_range(self):
+ """
+ Getter method for otn_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range (container)
+
+ YANG Description: Label range information for OTN.
+ """
+ return self.__otn_label_range
+
+ def _set_otn_label_range(self, v, load=False):
+ """
+ Setter method for otn_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_label_range() directly.
+
+ YANG Description: Label range information for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_label_range(self):
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_ethernet_label_range(self):
+ """
+ Getter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range (container)
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ return self.__ethernet_label_range
+
+ def _set_ethernet_label_range(self, v, load=False):
+ """
+ Setter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ethernet_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ethernet_label_range() directly.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ethernet_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__ethernet_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ethernet_label_range(self):
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+
+ restriction = __builtin__.property(_get_restriction)
+ index = __builtin__.property(_get_index)
+ label_start = __builtin__.property(_get_label_start)
+ label_end = __builtin__.property(_get_label_end)
+ label_step = __builtin__.property(_get_label_step)
+ range_bitmap = __builtin__.property(_get_range_bitmap)
+ otn_label_range = __builtin__.property(_get_otn_label_range)
+ ethernet_label_range = __builtin__.property(_get_ethernet_label_range)
+
+
+ _pyangbind_elements = OrderedDict([('restriction', restriction), ('index', index), ('label_start', label_start), ('label_end', label_end), ('label_step', label_step), ('range_bitmap', range_bitmap), ('otn_label_range', otn_label_range), ('ethernet_label_range', ethernet_label_range), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/ethernet_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/ethernet_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccc0a8bf938137b56874dff8b76cac52f6fe9f11
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/ethernet_label_range/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ethernet_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/ethernet-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tag_type','__priority',)
+
+ _yang_name = 'ethernet-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'ethernet-label-range']
+
+ def _get_tag_type(self):
+ """
+ Getter method for tag_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+
+ YANG Description: VLAN tag type.
+ """
+ return self.__tag_type
+
+ def _set_tag_type(self, v, load=False):
+ """
+ Setter method for tag_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tag_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tag_type() directly.
+
+ YANG Description: VLAN tag type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tag_type must be of a type compatible with etht-types:eth-tag-type""",
+ 'defined-type': "etht-types:eth-tag-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)""",
+ })
+
+ self.__tag_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tag_type(self):
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+
+ YANG Description: priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+
+ tag_type = __builtin__.property(_get_tag_type)
+ priority = __builtin__.property(_get_priority)
+
+
+ _pyangbind_elements = OrderedDict([('tag_type', tag_type), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_end/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..8116db8f36b36091805b53088883c23dacf04b29
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_end/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_end(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-end. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-end'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-end']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..7d689d60add0e4a98bdf1660273236a8e8fa0a4a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-end/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-end', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3dbff3b161cde1c2502bdbfdf693d91523aab36c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-end/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-end', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_start/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..c682b45e55c56f0da6fa132bd251230c253280af
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_start/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_start(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-start. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-start'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-start']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..3d28ae831e848224cc5e3c307bbaf3c4a3ad1357
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-start/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-start', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..458413ca8117db279493430de3d46d8e84404c84
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-start/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-start', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_step/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..817c68ae2952a3b519fb3d39519d1665660afaf9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_step/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class label_step(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-step. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_step',)
+
+ _yang_name = 'label-step'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-step']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/generic (int32)
+
+ YANG Description: Label range step.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/generic (int32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Label range step.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with int32""",
+ 'defined-type': "int32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn (container)
+
+ YANG Description: Label step for OTN
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label step for OTN
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_eth_step(self):
+ """
+ Getter method for eth_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/eth_step (uint16)
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ return self.__eth_step
+
+ def _set_eth_step(self, v, load=False):
+ """
+ Setter method for eth_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/eth_step (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_step() directly.
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_step must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__eth_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_step(self):
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ eth_step = __builtin__.property(_get_eth_step)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_step']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_step', eth_step), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_step/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_step/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..715687de97618e53b00342fe79a49f3812011355
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_step/otn/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-step/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label step for OTN
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-step', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/otn_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/otn_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..82fc8d6a107cf829ac674f2b2f6897c4fe4e9236
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/otn_label_range/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/otn-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label range information for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__range_type','__tsg','__odu_type_list','__priority',)
+
+ _yang_name = 'otn-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'otn-label-range']
+
+ def _get_range_type(self):
+ """
+ Getter method for range_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ return self.__range_type
+
+ def _set_range_type(self, v, load=False):
+ """
+ Setter method for range_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_type() directly.
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_type must be of a type compatible with otn-label-range-type""",
+ 'defined-type': "ietf-otn-topology:otn-label-range-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)""",
+ })
+
+ self.__range_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_type(self):
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_odu_type_list(self):
+ """
+ Getter method for odu_type_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ return self.__odu_type_list
+
+ def _set_odu_type_list(self, v, load=False):
+ """
+ Setter method for odu_type_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type_list() directly.
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type_list must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__odu_type_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type_list(self):
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+
+ range_type = __builtin__.property(_get_range_type)
+ tsg = __builtin__.property(_get_tsg)
+ odu_type_list = __builtin__.property(_get_odu_type_list)
+ priority = __builtin__.property(_get_priority)
+
+
+ _pyangbind_elements = OrderedDict([('range_type', range_type), ('tsg', tsg), ('odu_type_list', odu_type_list), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff0a5fab9e00c2dad085dd6e6878cd72be331294
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/__init__.py
@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import optimization_metric
+from . import tiebreakers
+from . import objective_function
+class optimizations(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__optimization_metric','__tiebreakers','__objective_function',)
+
+ _yang_name = 'optimizations'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations']
+
+ def _get_optimization_metric(self):
+ """
+ Getter method for optimization_metric, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__optimization_metric
+
+ def _set_optimization_metric(self, v, load=False):
+ """
+ Setter method for optimization_metric, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimization_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimization_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimization_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__optimization_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimization_metric(self):
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_tiebreakers(self):
+ """
+ Getter method for tiebreakers, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers (container)
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ return self.__tiebreakers
+
+ def _set_tiebreakers(self, v, load=False):
+ """
+ Setter method for tiebreakers, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreakers is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreakers() directly.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreakers must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__tiebreakers = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreakers(self):
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_objective_function(self):
+ """
+ Getter method for objective_function, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/objective_function (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__objective_function
+
+ def _set_objective_function(self, v, load=False):
+ """
+ Setter method for objective_function, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/objective_function (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__objective_function = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function(self):
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ optimization_metric = __builtin__.property(_get_optimization_metric)
+ tiebreakers = __builtin__.property(_get_tiebreakers)
+ objective_function = __builtin__.property(_get_objective_function)
+
+ __choices__ = {'algorithm': {'metric': ['optimization_metric', 'tiebreakers'], 'objective-function': ['objective_function']}}
+ _pyangbind_elements = OrderedDict([('optimization_metric', optimization_metric), ('tiebreakers', tiebreakers), ('objective_function', objective_function), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/objective_function/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/objective_function/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9fdbbbf68758cf2a463614b37e87d03b4915884
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/objective_function/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class objective_function(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/objective-function. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__objective_function_type',)
+
+ _yang_name = 'objective-function'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'objective-function']
+
+ def _get_objective_function_type(self):
+ """
+ Getter method for objective_function_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/objective_function/objective_function_type (identityref)
+
+ YANG Description: Objective function entry.
+ """
+ return self.__objective_function_type
+
+ def _set_objective_function_type(self, v, load=False):
+ """
+ Setter method for objective_function_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/objective_function/objective_function_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function_type() directly.
+
+ YANG Description: Objective function entry.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__objective_function_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function_type(self):
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+ objective_function_type = __builtin__.property(_get_objective_function_type)
+
+ __choices__ = {'algorithm': {'objective-function': ['objective_function_type']}}
+ _pyangbind_elements = OrderedDict([('objective_function_type', objective_function_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..74c142e286f35832cce0def7cfde3f1f063ad8dd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/__init__.py
@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import explicit_route_exclude_objects
+from . import explicit_route_include_objects
+class optimization_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__weight','__explicit_route_exclude_objects','__explicit_route_include_objects',)
+
+ _yang_name = 'optimization-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/metric_type (identityref)
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_weight(self):
+ """
+ Getter method for weight, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/weight (uint8)
+
+ YANG Description: TE path metric normalization weight.
+ """
+ return self.__weight
+
+ def _set_weight(self, v, load=False):
+ """
+ Setter method for weight, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/weight (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_weight is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_weight() directly.
+
+ YANG Description: TE path metric normalization weight.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """weight must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__weight = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_weight(self):
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+
+
+ def _get_explicit_route_exclude_objects(self):
+ """
+ Getter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ return self.__explicit_route_exclude_objects
+
+ def _set_explicit_route_exclude_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_exclude_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_exclude_objects() directly.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_exclude_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__explicit_route_exclude_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_exclude_objects(self):
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_explicit_route_include_objects(self):
+ """
+ Getter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects (container)
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ return self.__explicit_route_include_objects
+
+ def _set_explicit_route_include_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_include_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_include_objects() directly.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_include_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__explicit_route_include_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_include_objects(self):
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ metric_type = __builtin__.property(_get_metric_type)
+ weight = __builtin__.property(_get_weight)
+ explicit_route_exclude_objects = __builtin__.property(_get_explicit_route_exclude_objects)
+ explicit_route_include_objects = __builtin__.property(_get_explicit_route_include_objects)
+
+ __choices__ = {'algorithm': {'metric': ['metric_type', 'weight', 'explicit_route_exclude_objects', 'explicit_route_include_objects']}}
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('weight', weight), ('explicit_route_exclude_objects', explicit_route_exclude_objects), ('explicit_route_include_objects', explicit_route_include_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed88eea0523e3f83d8f162ce0bbec135e0dc81fa
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_exclude_object
+class explicit_route_exclude_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_exclude_object',)
+
+ _yang_name = 'explicit-route-exclude-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects']
+
+ def _get_route_object_exclude_object(self):
+ """
+ Getter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ return self.__route_object_exclude_object
+
+ def _set_route_object_exclude_object(self, v, load=False):
+ """
+ Setter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_exclude_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_exclude_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_exclude_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__route_object_exclude_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_exclude_object(self):
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ route_object_exclude_object = __builtin__.property(_get_route_object_exclude_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_exclude_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_exclude_object', route_object_exclude_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad5bff3e1db5d7ba061f150470e3c611553f7ed6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
@@ -0,0 +1,365 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+from . import srlg
+class route_object_exclude_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop','__srlg',)
+
+ _yang_name = 'route-object-exclude-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+
+ YANG Description: SRLG container.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+ srlg = __builtin__.property(_get_srlg)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop'], 'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..40a38d18d628ed146248bdc5225294c9735e8f71
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d86889be2e17816277f7cc9d2f844cf3bbfeeb2e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b404a2341dd3c0b52f3ddcf6d370a8649aa6252b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fbabbb174ea802870622969f3ebfdc96041ec866
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a9ce25d09b5b8f875683b6ddfb480498d02c772
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..81ae5ee3b77f37707e2da604edf964ff04ec629a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba86eb284b0d67d02217472f28df7cd6bcaec674
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py
@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class srlg(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/srlg. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: SRLG container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__srlg',)
+
+ _yang_name = 'srlg'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__srlg = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'srlg']
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/srlg (uint32)
+
+ YANG Description: SRLG value.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/srlg (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+ srlg = __builtin__.property(_get_srlg)
+
+ __choices__ = {'type': {'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..edb8b9e25e13ebe6ee7960ab0f7c5e2d8dee9012
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..21986a9121fe59debbe172846f8a3555461a08dd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_include_object
+class explicit_route_include_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_include_object',)
+
+ _yang_name = 'explicit-route-include-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_include_object = YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects']
+
+ def _get_route_object_include_object(self):
+ """
+ Getter method for route_object_include_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object (list)
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ return self.__route_object_include_object
+
+ def _set_route_object_include_object(self, v, load=False):
+ """
+ Setter method for route_object_include_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_include_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_include_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_include_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__route_object_include_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_include_object(self):
+ self.__route_object_include_object = YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ route_object_include_object = __builtin__.property(_get_route_object_include_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_include_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_include_object', route_object_include_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5140272eec2eedae3de75b2f870493f81ce95e8a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py
@@ -0,0 +1,325 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class route_object_include_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'route-object-include-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f65b4645ffa752af6fd7b7d7fb5b666c4e06fa4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..882e1f01ad2e280789f31daa41c1cfd7db8c0b0b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2dde61c314cd20e407b23b60262896426b0bad5a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..784b431b63e8e1512737a4aa72e186a0fdc7425d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..14455045c23fefc0083d02c80eb537bb6fd7a1d8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..70eea9f9a90b0c4be8d37bf71a715c92654a731b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb61c881e99e645a8ba8de8a09eeb50add524777
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c6d935272024dc3c1b00e6c99bda99b30961f06
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tiebreaker
+class tiebreakers(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/tiebreakers. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tiebreaker',)
+
+ _yang_name = 'tiebreakers'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tiebreaker = YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'tiebreakers']
+
+ def _get_tiebreaker(self):
+ """
+ Getter method for tiebreaker, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker (list)
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ return self.__tiebreaker
+
+ def _set_tiebreaker(self, v, load=False):
+ """
+ Setter method for tiebreaker, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreaker is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreaker() directly.
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreaker must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__tiebreaker = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreaker(self):
+ self.__tiebreaker = YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ tiebreaker = __builtin__.property(_get_tiebreaker)
+
+ __choices__ = {'algorithm': {'metric': ['tiebreaker']}}
+ _pyangbind_elements = OrderedDict([('tiebreaker', tiebreaker), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..52b5c81b73875d53580d39558efa2b25529d3ea6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker/__init__.py
@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tiebreaker(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/optimizations/tiebreakers/tiebreaker. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tiebreaker_type',)
+
+ _yang_name = 'tiebreaker'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tiebreaker_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'tiebreakers', 'tiebreaker']
+
+ def _get_tiebreaker_type(self):
+ """
+ Getter method for tiebreaker_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker/tiebreaker_type (identityref)
+
+ YANG Description: Identifies an entry in the list of tiebreakers.
+ """
+ return self.__tiebreaker_type
+
+ def _set_tiebreaker_type(self, v, load=False):
+ """
+ Setter method for tiebreaker_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker/tiebreaker_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreaker_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreaker_type() directly.
+
+ YANG Description: Identifies an entry in the list of tiebreakers.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreaker_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tiebreaker_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreaker_type(self):
+ self.__tiebreaker_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+ tiebreaker_type = __builtin__.property(_get_tiebreaker_type)
+
+ __choices__ = {'algorithm': {'metric': ['tiebreaker_type']}}
+ _pyangbind_elements = OrderedDict([('tiebreaker_type', tiebreaker_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..36a802786ce00a6338c3c1e09e7054ca2b79cf39
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py
@@ -0,0 +1,523 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+from . import path_metric_bounds
+from . import path_affinities_values
+from . import path_affinity_names
+from . import path_srlgs_lists
+from . import path_srlgs_names
+class path_constraints(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE named path constraints container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_bandwidth','__link_protection','__setup_priority','__hold_priority','__signaling_type','__path_metric_bounds','__path_affinities_values','__path_affinity_names','__path_srlgs_lists','__path_srlgs_names','__disjointness',)
+
+ _yang_name = 'path-constraints'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__link_protection = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__setup_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ self.__hold_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ self.__signaling_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__path_metric_bounds = YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__disjointness = YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints']
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_link_protection(self):
+ """
+ Getter method for link_protection, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/link_protection (identityref)
+
+ YANG Description: Link protection type required for the links included
+in the computed path.
+ """
+ return self.__link_protection
+
+ def _set_link_protection(self, v, load=False):
+ """
+ Setter method for link_protection, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/link_protection (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_protection is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_protection() directly.
+
+ YANG Description: Link protection type required for the links included
+in the computed path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_protection must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__link_protection = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_protection(self):
+ self.__link_protection = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_setup_priority(self):
+ """
+ Getter method for setup_priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/setup_priority (uint8)
+
+ YANG Description: TE LSP requested setup priority.
+ """
+ return self.__setup_priority
+
+ def _set_setup_priority(self, v, load=False):
+ """
+ Setter method for setup_priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/setup_priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_setup_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_setup_priority() directly.
+
+ YANG Description: TE LSP requested setup priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """setup_priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__setup_priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_setup_priority(self):
+ self.__setup_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+
+
+ def _get_hold_priority(self):
+ """
+ Getter method for hold_priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/hold_priority (uint8)
+
+ YANG Description: TE LSP requested hold priority.
+ """
+ return self.__hold_priority
+
+ def _set_hold_priority(self, v, load=False):
+ """
+ Setter method for hold_priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/hold_priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hold_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hold_priority() directly.
+
+ YANG Description: TE LSP requested hold priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hold_priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__hold_priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hold_priority(self):
+ self.__hold_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+
+
+ def _get_signaling_type(self):
+ """
+ Getter method for signaling_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/signaling_type (identityref)
+
+ YANG Description: TE tunnel path signaling type.
+ """
+ return self.__signaling_type
+
+ def _set_signaling_type(self, v, load=False):
+ """
+ Setter method for signaling_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/signaling_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_signaling_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_signaling_type() directly.
+
+ YANG Description: TE tunnel path signaling type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """signaling_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__signaling_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_signaling_type(self):
+ self.__signaling_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_path_metric_bounds(self):
+ """
+ Getter method for path_metric_bounds, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds (container)
+
+ YANG Description: TE path metric bounds container.
+ """
+ return self.__path_metric_bounds
+
+ def _set_path_metric_bounds(self, v, load=False):
+ """
+ Setter method for path_metric_bounds, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric_bounds is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric_bounds() directly.
+
+ YANG Description: TE path metric bounds container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric_bounds must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_metric_bounds = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric_bounds(self):
+ self.__path_metric_bounds = YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_affinities_values(self):
+ """
+ Getter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values (container)
+
+ YANG Description: Path affinities represented as values.
+ """
+ return self.__path_affinities_values
+
+ def _set_path_affinities_values(self, v, load=False):
+ """
+ Setter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_values() directly.
+
+ YANG Description: Path affinities represented as values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_values must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinities_values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_values(self):
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_affinity_names(self):
+ """
+ Getter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names (container)
+
+ YANG Description: Path affinities represented as names.
+ """
+ return self.__path_affinity_names
+
+ def _set_path_affinity_names(self, v, load=False):
+ """
+ Setter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_names() directly.
+
+ YANG Description: Path affinities represented as names.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinity_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_names(self):
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_lists(self):
+ """
+ Getter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists (container)
+
+ YANG Description: Path SRLG properties container.
+ """
+ return self.__path_srlgs_lists
+
+ def _set_path_srlgs_lists(self, v, load=False):
+ """
+ Setter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_lists is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_lists() directly.
+
+ YANG Description: Path SRLG properties container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_lists must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_lists = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_lists(self):
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_names(self):
+ """
+ Getter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names (container)
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ return self.__path_srlgs_names
+
+ def _set_path_srlgs_names(self, v, load=False):
+ """
+ Setter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_names() directly.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_names(self):
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_disjointness(self):
+ """
+ Getter method for disjointness, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/disjointness (te-path-disjointness)
+
+ YANG Description: The type of resource disjointness.
+When configured for a primary path, the disjointness level
+applies to all secondary LSPs. When configured for a
+secondary path, the disjointness level overrides the level
+configured for the primary path.
+ """
+ return self.__disjointness
+
+ def _set_disjointness(self, v, load=False):
+ """
+ Setter method for disjointness, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/disjointness (te-path-disjointness)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_disjointness is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_disjointness() directly.
+
+ YANG Description: The type of resource disjointness.
+When configured for a primary path, the disjointness level
+applies to all secondary LSPs. When configured for a
+secondary path, the disjointness level overrides the level
+configured for the primary path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """disjointness must be of a type compatible with te-path-disjointness""",
+ 'defined-type': "ietf-te-topology:te-path-disjointness",
+ 'generated-type': """YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=False)""",
+ })
+
+ self.__disjointness = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_disjointness(self):
+ self.__disjointness = YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=False)
+
+ te_bandwidth = __builtin__.property(_get_te_bandwidth)
+ link_protection = __builtin__.property(_get_link_protection)
+ setup_priority = __builtin__.property(_get_setup_priority)
+ hold_priority = __builtin__.property(_get_hold_priority)
+ signaling_type = __builtin__.property(_get_signaling_type)
+ path_metric_bounds = __builtin__.property(_get_path_metric_bounds)
+ path_affinities_values = __builtin__.property(_get_path_affinities_values)
+ path_affinity_names = __builtin__.property(_get_path_affinity_names)
+ path_srlgs_lists = __builtin__.property(_get_path_srlgs_lists)
+ path_srlgs_names = __builtin__.property(_get_path_srlgs_names)
+ disjointness = __builtin__.property(_get_disjointness)
+
+
+ _pyangbind_elements = OrderedDict([('te_bandwidth', te_bandwidth), ('link_protection', link_protection), ('setup_priority', setup_priority), ('hold_priority', hold_priority), ('signaling_type', signaling_type), ('path_metric_bounds', path_metric_bounds), ('path_affinities_values', path_affinities_values), ('path_affinity_names', path_affinity_names), ('path_srlgs_lists', path_srlgs_lists), ('path_srlgs_names', path_srlgs_names), ('disjointness', disjointness), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..aec7be61a4d5a62743420173d73c07dc98f4c0b7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinities_value
+class path_affinities_values(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-affinities-values. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as values.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinities_value',)
+
+ _yang_name = 'path-affinities-values'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-affinities-values']
+
+ def _get_path_affinities_value(self):
+ """
+ Getter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinities_value
+
+ def _set_path_affinities_value(self, v, load=False):
+ """
+ Setter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_value() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_value must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinities_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_value(self):
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinities_value = __builtin__.property(_get_path_affinities_value)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinities_value', path_affinities_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..7a8d69da62bff28db4a5c294238a07d4fd36df9e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_affinities_value(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-affinities-values/path-affinities-value. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__value',)
+
+ _yang_name = 'path-affinities-value'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-affinities-values', 'path-affinities-value']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/value (admin-groups)
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/value (admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with admin-groups""",
+ 'defined-type': "ietf-te-topology:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ value = __builtin__.property(_get_value)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..ac5c598a48c14e1beed8d680b6da8c350b0eeacc
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinity_name
+class path_affinity_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-affinity-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as names.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinity_name',)
+
+ _yang_name = 'path-affinity-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-affinity-names']
+
+ def _get_path_affinity_name(self):
+ """
+ Getter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinity_name
+
+ def _set_path_affinity_name(self, v, load=False):
+ """
+ Setter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_name() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_name(self):
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinity_name = __builtin__.property(_get_path_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinity_name', path_affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..df70c3c795414c8923b496cc519a630c3fbac04b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import affinity_name
+class path_affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-affinity-names/path-affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__affinity_name',)
+
+ _yang_name = 'path-affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-affinity-names', 'path-affinity-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_affinity_name(self):
+ """
+ Getter method for affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name (list)
+
+ YANG Description: List of named affinities.
+ """
+ return self.__affinity_name
+
+ def _set_affinity_name(self, v, load=False):
+ """
+ Setter method for affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_affinity_name() directly.
+
+ YANG Description: List of named affinities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_affinity_name(self):
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ affinity_name = __builtin__.property(_get_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('affinity_name', affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..5b69454e75f6d6e0971bc82173c8f01e5572eb27
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-affinity-names/path-affinity-name/affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__name',)
+
+ _yang_name = 'affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-affinity-names', 'path-affinity-name', 'affinity-name']
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name/name (string)
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ name = __builtin__.property(_get_name)
+
+
+ _pyangbind_elements = OrderedDict([('name', name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..d5df4f4698edf0430c3d4e4a063ff3af693f8039
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_metric_bound
+class path_metric_bounds(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-metric-bounds. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric bounds container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_metric_bound',)
+
+ _yang_name = 'path-metric-bounds'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_metric_bound = YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-metric-bounds']
+
+ def _get_path_metric_bound(self):
+ """
+ Getter method for path_metric_bound, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound (list)
+
+ YANG Description: List of TE path metric bounds.
+ """
+ return self.__path_metric_bound
+
+ def _set_path_metric_bound(self, v, load=False):
+ """
+ Setter method for path_metric_bound, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric_bound is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric_bound() directly.
+
+ YANG Description: List of TE path metric bounds.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric_bound must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_metric_bound = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric_bound(self):
+ self.__path_metric_bound = YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_metric_bound = __builtin__.property(_get_path_metric_bound)
+
+
+ _pyangbind_elements = OrderedDict([('path_metric_bound', path_metric_bound), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..fd7e445c0d416fe1cd5778f0a07f32503cb30a26
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,165 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_metric_bound(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-metric-bounds/path-metric-bound. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of TE path metric bounds.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__upper_bound',)
+
+ _yang_name = 'path-metric-bound'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__upper_bound = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-metric-bounds', 'path-metric-bound']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/metric_type (identityref)
+
+ YANG Description: Identifies an entry in the list of 'metric-type' items
+bound for the TE path.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies an entry in the list of 'metric-type' items
+bound for the TE path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_upper_bound(self):
+ """
+ Getter method for upper_bound, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/upper_bound (uint64)
+
+ YANG Description: Upper bound on the end-to-end TE path metric. A zero
+indicates an unbounded upper limit for the specific
+'metric-type'.
+ """
+ return self.__upper_bound
+
+ def _set_upper_bound(self, v, load=False):
+ """
+ Setter method for upper_bound, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/upper_bound (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_upper_bound is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_upper_bound() directly.
+
+ YANG Description: Upper bound on the end-to-end TE path metric. A zero
+indicates an unbounded upper limit for the specific
+'metric-type'.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """upper_bound must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__upper_bound = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_upper_bound(self):
+ self.__upper_bound = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ metric_type = __builtin__.property(_get_metric_type)
+ upper_bound = __builtin__.property(_get_upper_bound)
+
+
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('upper_bound', upper_bound), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..f089523be84c77715f2ef69f20fee14ddd096c4a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_list
+class path_srlgs_lists(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-srlgs-lists. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path SRLG properties container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_list',)
+
+ _yang_name = 'path-srlgs-lists'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-srlgs-lists']
+
+ def _get_path_srlgs_list(self):
+ """
+ Getter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list (list)
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ return self.__path_srlgs_list
+
+ def _set_path_srlgs_list(self, v, load=False):
+ """
+ Setter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_list() directly.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_list must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_list(self):
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_list = __builtin__.property(_get_path_srlgs_list)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_list', path_srlgs_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..b48cb25ffa81f50cf1d51a2efc2e7ef82f6eb6db
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_list(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-srlgs-lists/path-srlgs-list. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__values',)
+
+ _yang_name = 'path-srlgs-list'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-srlgs-lists', 'path-srlgs-list']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_values(self):
+ """
+ Getter method for values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/values (srlg)
+
+ YANG Description: List of SRLG values.
+ """
+ return self.__values
+
+ def _set_values(self, v, load=False):
+ """
+ Setter method for values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/values (srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_values() directly.
+
+ YANG Description: List of SRLG values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """values must be of a type compatible with srlg""",
+ 'defined-type': "ietf-te-topology:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)""",
+ })
+
+ self.__values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_values(self):
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ values = __builtin__.property(_get_values)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('values', values), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..d18d1658d5bb0cd62f7a9adec7140b198f27df3a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_name
+class path_srlgs_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-srlgs-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_name',)
+
+ _yang_name = 'path-srlgs-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-srlgs-names']
+
+ def _get_path_srlgs_name(self):
+ """
+ Getter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name (list)
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ return self.__path_srlgs_name
+
+ def _set_path_srlgs_name(self, v, load=False):
+ """
+ Setter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_name() directly.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_name(self):
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_name = __builtin__.property(_get_path_srlgs_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_name', path_srlgs_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..cee736f2442ff529b658cda7cb8631a1580d9776
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/path-srlgs-names/path-srlgs-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__names',)
+
+ _yang_name = 'path-srlgs-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-srlgs-names', 'path-srlgs-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_names(self):
+ """
+ Getter method for names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/names (string)
+
+ YANG Description: List of named SRLGs.
+ """
+ return self.__names
+
+ def _set_names(self, v, load=False):
+ """
+ Setter method for names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/names (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_names() directly.
+
+ YANG Description: List of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """names must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_names(self):
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ names = __builtin__.property(_get_names)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('names', names), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a079dcabfae8a4a267d46459bd88664e9c3f8723
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_bandwidth']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b5dd7c31d174362032052dfb9c602cbe4c29c0c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/__init__.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist','__odtu_flex_type',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+
+
+ def _get_odtu_flex_type(self):
+ """
+ Getter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+set up along the underlay path of this OTN
+connectivity matrix entry.
+ """
+ return self.__odtu_flex_type
+
+ def _set_odtu_flex_type(self, v, load=False):
+ """
+ Setter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odtu_flex_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odtu_flex_type() directly.
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+set up along the underlay path of this OTN
+connectivity matrix entry.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odtu_flex_type must be of a type compatible with l1-types:odtu-flex-type""",
+ 'defined-type': "l1-types:odtu-flex-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=False)""",
+ })
+
+ self.__odtu_flex_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odtu_flex_type(self):
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=False)
+
+ odulist = __builtin__.property(_get_odulist)
+ odtu_flex_type = __builtin__.property(_get_odtu_flex_type)
+
+ __choices__ = {'technology': {'otn': ['odulist', 'odtu_flex_type']}}
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ('odtu_flex_type', odtu_flex_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..afa750977534afaf21fff915a0144bc78bdde0d0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-constraints/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ odu_type = __builtin__.property(_get_odu_type)
+ number = __builtin__.property(_get_number)
+ ts_number = __builtin__.property(_get_ts_number)
+
+ __choices__ = {'technology': {'otn': ['odu_type', 'number', 'ts_number']}}
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f87c34494c5e902ec0b191b491c9f87048a71fc0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/__init__.py
@@ -0,0 +1,318 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_metric
+from . import path_affinities_values
+from . import path_affinity_names
+from . import path_srlgs_lists
+from . import path_srlgs_names
+from . import path_route_objects
+class path_properties(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The TE path properties.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_metric','__path_affinities_values','__path_affinity_names','__path_srlgs_lists','__path_srlgs_names','__path_route_objects',)
+
+ _yang_name = 'path-properties'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_metric = YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_route_objects = YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties']
+
+ def _get_path_metric(self):
+ """
+ Getter method for path_metric, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__path_metric
+
+ def _set_path_metric(self, v, load=False):
+ """
+ Setter method for path_metric, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric(self):
+ self.__path_metric = YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_path_affinities_values(self):
+ """
+ Getter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values (container)
+
+ YANG Description: Path affinities represented as values.
+ """
+ return self.__path_affinities_values
+
+ def _set_path_affinities_values(self, v, load=False):
+ """
+ Setter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_values() directly.
+
+ YANG Description: Path affinities represented as values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_values must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinities_values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_values(self):
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_affinity_names(self):
+ """
+ Getter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names (container)
+
+ YANG Description: Path affinities represented as names.
+ """
+ return self.__path_affinity_names
+
+ def _set_path_affinity_names(self, v, load=False):
+ """
+ Setter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_names() directly.
+
+ YANG Description: Path affinities represented as names.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinity_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_names(self):
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_lists(self):
+ """
+ Getter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists (container)
+
+ YANG Description: Path SRLG properties container.
+ """
+ return self.__path_srlgs_lists
+
+ def _set_path_srlgs_lists(self, v, load=False):
+ """
+ Setter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_lists is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_lists() directly.
+
+ YANG Description: Path SRLG properties container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_lists must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_lists = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_lists(self):
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_names(self):
+ """
+ Getter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names (container)
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ return self.__path_srlgs_names
+
+ def _set_path_srlgs_names(self, v, load=False):
+ """
+ Setter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_names() directly.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_names(self):
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_route_objects(self):
+ """
+ Getter method for path_route_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects (container)
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ return self.__path_route_objects
+
+ def _set_path_route_objects(self, v, load=False):
+ """
+ Setter method for path_route_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_route_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_route_objects() directly.
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_route_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_route_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_route_objects(self):
+ self.__path_route_objects = YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ path_metric = __builtin__.property(_get_path_metric)
+ path_affinities_values = __builtin__.property(_get_path_affinities_values)
+ path_affinity_names = __builtin__.property(_get_path_affinity_names)
+ path_srlgs_lists = __builtin__.property(_get_path_srlgs_lists)
+ path_srlgs_names = __builtin__.property(_get_path_srlgs_names)
+ path_route_objects = __builtin__.property(_get_path_route_objects)
+
+
+ _pyangbind_elements = OrderedDict([('path_metric', path_metric), ('path_affinities_values', path_affinities_values), ('path_affinity_names', path_affinity_names), ('path_srlgs_lists', path_srlgs_lists), ('path_srlgs_names', path_srlgs_names), ('path_route_objects', path_route_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..5e54de27228aad73fbca118fde3e1fa2376541cf
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinities_value
+class path_affinities_values(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-affinities-values. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as values.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinities_value',)
+
+ _yang_name = 'path-affinities-values'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-affinities-values']
+
+ def _get_path_affinities_value(self):
+ """
+ Getter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinities_value
+
+ def _set_path_affinities_value(self, v, load=False):
+ """
+ Setter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_value() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_value must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinities_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_value(self):
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinities_value = __builtin__.property(_get_path_affinities_value)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinities_value', path_affinities_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..df6fd94eb524085ace9f530e78b2c21b279c795f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_affinities_value(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-affinities-values/path-affinities-value. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__value',)
+
+ _yang_name = 'path-affinities-value'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-affinities-values', 'path-affinities-value']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/value (admin-groups)
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/value (admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with admin-groups""",
+ 'defined-type': "ietf-te-topology:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ value = __builtin__.property(_get_value)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..97969b43740067ba7b3f079983f8f43c624d1466
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinity_name
+class path_affinity_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-affinity-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as names.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinity_name',)
+
+ _yang_name = 'path-affinity-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-affinity-names']
+
+ def _get_path_affinity_name(self):
+ """
+ Getter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinity_name
+
+ def _set_path_affinity_name(self, v, load=False):
+ """
+ Setter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_name() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_name(self):
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinity_name = __builtin__.property(_get_path_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinity_name', path_affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..47b1cb4768bb609d795a99ea877462d5143a3976
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import affinity_name
+class path_affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-affinity-names/path-affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__affinity_name',)
+
+ _yang_name = 'path-affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-affinity-names', 'path-affinity-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_affinity_name(self):
+ """
+ Getter method for affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name (list)
+
+ YANG Description: List of named affinities.
+ """
+ return self.__affinity_name
+
+ def _set_affinity_name(self, v, load=False):
+ """
+ Setter method for affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_affinity_name() directly.
+
+ YANG Description: List of named affinities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_affinity_name(self):
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ affinity_name = __builtin__.property(_get_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('affinity_name', affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..043b7900eaed4d12e772026171a965693e6fb371
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-affinity-names/path-affinity-name/affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__name',)
+
+ _yang_name = 'affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-affinity-names', 'path-affinity-name', 'affinity-name']
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name/name (string)
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ name = __builtin__.property(_get_name)
+
+
+ _pyangbind_elements = OrderedDict([('name', name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..46350a791d4cda3328317288a91d8f1b6dc41515
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py
@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__accumulative_value',)
+
+ _yang_name = 'path-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__accumulative_value = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric/metric_type (identityref)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: TE path metric type.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_accumulative_value(self):
+ """
+ Getter method for accumulative_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric/accumulative_value (uint64)
+
+ YANG Description: TE path metric accumulative value.
+ """
+ return self.__accumulative_value
+
+ def _set_accumulative_value(self, v, load=False):
+ """
+ Setter method for accumulative_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric/accumulative_value (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_accumulative_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_accumulative_value() directly.
+
+ YANG Description: TE path metric accumulative value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """accumulative_value must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__accumulative_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_accumulative_value(self):
+ self.__accumulative_value = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ metric_type = __builtin__.property(_get_metric_type)
+ accumulative_value = __builtin__.property(_get_accumulative_value)
+
+
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('accumulative_value', accumulative_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..cd515c92f9c87e5fead687d05f45a09c2a94a494
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_route_object
+class path_route_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_route_object',)
+
+ _yang_name = 'path-route-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_route_object = YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects']
+
+ def _get_path_route_object(self):
+ """
+ Getter method for path_route_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object (list)
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ return self.__path_route_object
+
+ def _set_path_route_object(self, v, load=False):
+ """
+ Setter method for path_route_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_route_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_route_object() directly.
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_route_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_route_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_route_object(self):
+ self.__path_route_object = YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_route_object = __builtin__.property(_get_path_route_object)
+
+
+ _pyangbind_elements = OrderedDict([('path_route_object', path_route_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..1161f751e512844bdf95a624bf007614f735a69e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,327 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_route_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-route-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key
+values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key
+values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b257ffed78be11f619693f26c8ac4ed962d9dbf6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1740e147ea928bcfad9d102a2911d91d2e4e19d7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f69cf8311d9b085775451b9553f4b2189c23dc10
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8b6d2f8d0f71572c858c6119f28b9d849b147d1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..af1242f7df8795d13bc589e60a08bc0064c961a6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d06026657464feb50eef363ce1661c1aca5b0e9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce5442e682e33f23002793fdd0316cb570c8e77e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..9eeb9f3bc0897e087dbb923f08aa12eca8acd9e8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_list
+class path_srlgs_lists(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-srlgs-lists. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path SRLG properties container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_list',)
+
+ _yang_name = 'path-srlgs-lists'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-srlgs-lists']
+
+ def _get_path_srlgs_list(self):
+ """
+ Getter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list (list)
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ return self.__path_srlgs_list
+
+ def _set_path_srlgs_list(self, v, load=False):
+ """
+ Setter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_list() directly.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_list must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_list(self):
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_list = __builtin__.property(_get_path_srlgs_list)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_list', path_srlgs_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..1055b900a70cb06d2e5f85b4483a8fe86a9edd9d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_list(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-srlgs-lists/path-srlgs-list. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__values',)
+
+ _yang_name = 'path-srlgs-list'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-srlgs-lists', 'path-srlgs-list']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_values(self):
+ """
+ Getter method for values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/values (srlg)
+
+ YANG Description: List of SRLG values.
+ """
+ return self.__values
+
+ def _set_values(self, v, load=False):
+ """
+ Setter method for values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/values (srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_values() directly.
+
+ YANG Description: List of SRLG values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """values must be of a type compatible with srlg""",
+ 'defined-type': "ietf-te-topology:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)""",
+ })
+
+ self.__values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_values(self):
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ values = __builtin__.property(_get_values)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('values', values), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..796ccb5f22347bf51b003e64b52d420885ca2303
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_name
+class path_srlgs_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-srlgs-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_name',)
+
+ _yang_name = 'path-srlgs-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-srlgs-names']
+
+ def _get_path_srlgs_name(self):
+ """
+ Getter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name (list)
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ return self.__path_srlgs_name
+
+ def _set_path_srlgs_name(self, v, load=False):
+ """
+ Setter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_name() directly.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_name(self):
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_name = __builtin__.property(_get_path_srlgs_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_name', path_srlgs_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..bdfa7bcab051555880838320ed60dcb06c1e9439
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/path-properties/path-srlgs-names/path-srlgs-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__names',)
+
+ _yang_name = 'path-srlgs-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-srlgs-names', 'path-srlgs-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_names(self):
+ """
+ Getter method for names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/names (string)
+
+ YANG Description: List of named SRLGs.
+ """
+ return self.__names
+
+ def _set_names(self, v, load=False):
+ """
+ Setter method for names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/names (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_names() directly.
+
+ YANG Description: List of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """names must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_names(self):
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ names = __builtin__.property(_get_names)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('names', names), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..71191caa02af70c0c425dc03e155ef14be19c1bb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/__init__.py
@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restrictions
+class to(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Reference to a destination LTP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tp_ref','__label_restrictions',)
+
+ _yang_name = 'to'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to']
+
+ def _get_tp_ref(self):
+ """
+ Getter method for tp_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/tp_ref (leafref)
+
+ YANG Description: Relative reference to a termination point.
+ """
+ return self.__tp_ref
+
+ def _set_tp_ref(self, v, load=False):
+ """
+ Setter method for tp_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/tp_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tp_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tp_ref() directly.
+
+ YANG Description: Relative reference to a termination point.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tp_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__tp_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tp_ref(self):
+ self.__tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+
+ def _get_label_restrictions(self):
+ """
+ Getter method for label_restrictions, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions (container)
+
+ YANG Description: The label restrictions container.
+ """
+ return self.__label_restrictions
+
+ def _set_label_restrictions(self, v, load=False):
+ """
+ Setter method for label_restrictions, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restrictions is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restrictions() directly.
+
+ YANG Description: The label restrictions container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restrictions must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_restrictions = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restrictions(self):
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ tp_ref = __builtin__.property(_get_tp_ref)
+ label_restrictions = __builtin__.property(_get_label_restrictions)
+
+
+ _pyangbind_elements = OrderedDict([('tp_ref', tp_ref), ('label_restrictions', label_restrictions), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3873a02ce4893dd956ce47d381bb005e268c944a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restriction
+class label_restrictions(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The label restrictions container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__label_restriction',)
+
+ _yang_name = 'label-restrictions'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions']
+
+ def _get_label_restriction(self):
+ """
+ Getter method for label_restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction (list)
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ return self.__label_restriction
+
+ def _set_label_restriction(self, v, load=False):
+ """
+ Setter method for label_restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restriction() directly.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restriction must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__label_restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restriction(self):
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ label_restriction = __builtin__.property(_get_label_restriction)
+
+
+ _pyangbind_elements = OrderedDict([('label_restriction', label_restriction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..dbf240ba846fa6468376de6985a59828653c0b8a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/__init__.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_start
+from . import label_end
+from . import label_step
+from . import otn_label_range
+from . import ethernet_label_range
+class label_restriction(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restriction','__index','__label_start','__label_end','__label_step','__range_bitmap','__otn_label_range','__ethernet_label_range',)
+
+ _yang_name = 'label-restriction'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction']
+
+ def _get_restriction(self):
+ """
+ Getter method for restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/restriction (enumeration)
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ return self.__restriction
+
+ def _set_restriction(self, v, load=False):
+ """
+ Setter method for restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/restriction (enumeration)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restriction() directly.
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restriction must be of a type compatible with enumeration""",
+ 'defined-type': "ietf-te-topology:enumeration",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)""",
+ })
+
+ self.__restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restriction(self):
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/index (uint32)
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_label_start(self):
+ """
+ Getter method for label_start, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start (container)
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ return self.__label_start
+
+ def _set_label_start(self, v, load=False):
+ """
+ Setter method for label_start, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_start is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_start() directly.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_start must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_start = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_start(self):
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_end(self):
+ """
+ Getter method for label_end, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end (container)
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ return self.__label_end
+
+ def _set_label_end(self, v, load=False):
+ """
+ Setter method for label_end, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_end is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_end() directly.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_end must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_end = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_end(self):
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_step(self):
+ """
+ Getter method for label_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step (container)
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ return self.__label_step
+
+ def _set_label_step(self, v, load=False):
+ """
+ Setter method for label_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_step() directly.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_step must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_step(self):
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_range_bitmap(self):
+ """
+ Getter method for range_bitmap, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ return self.__range_bitmap
+
+ def _set_range_bitmap(self, v, load=False):
+ """
+ Setter method for range_bitmap, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_bitmap is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_bitmap() directly.
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_bitmap must be of a type compatible with yang:hex-string""",
+ 'defined-type': "yang:hex-string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)""",
+ })
+
+ self.__range_bitmap = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_bitmap(self):
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+
+
+ def _get_otn_label_range(self):
+ """
+ Getter method for otn_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range (container)
+
+ YANG Description: Label range information for OTN.
+ """
+ return self.__otn_label_range
+
+ def _set_otn_label_range(self, v, load=False):
+ """
+ Setter method for otn_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_label_range() directly.
+
+ YANG Description: Label range information for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_label_range(self):
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_ethernet_label_range(self):
+ """
+ Getter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range (container)
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ return self.__ethernet_label_range
+
+ def _set_ethernet_label_range(self, v, load=False):
+ """
+ Setter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ethernet_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ethernet_label_range() directly.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ethernet_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__ethernet_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ethernet_label_range(self):
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+
+ restriction = __builtin__.property(_get_restriction)
+ index = __builtin__.property(_get_index)
+ label_start = __builtin__.property(_get_label_start)
+ label_end = __builtin__.property(_get_label_end)
+ label_step = __builtin__.property(_get_label_step)
+ range_bitmap = __builtin__.property(_get_range_bitmap)
+ otn_label_range = __builtin__.property(_get_otn_label_range)
+ ethernet_label_range = __builtin__.property(_get_ethernet_label_range)
+
+
+ _pyangbind_elements = OrderedDict([('restriction', restriction), ('index', index), ('label_start', label_start), ('label_end', label_end), ('label_step', label_step), ('range_bitmap', range_bitmap), ('otn_label_range', otn_label_range), ('ethernet_label_range', ethernet_label_range), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f672822b48accb14de87483e9dd12867456df08
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ethernet_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/ethernet-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tag_type','__priority',)
+
+ _yang_name = 'ethernet-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'ethernet-label-range']
+
+ def _get_tag_type(self):
+ """
+ Getter method for tag_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+
+ YANG Description: VLAN tag type.
+ """
+ return self.__tag_type
+
+ def _set_tag_type(self, v, load=False):
+ """
+ Setter method for tag_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tag_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tag_type() directly.
+
+ YANG Description: VLAN tag type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tag_type must be of a type compatible with etht-types:eth-tag-type""",
+ 'defined-type': "etht-types:eth-tag-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)""",
+ })
+
+ self.__tag_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tag_type(self):
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+
+ YANG Description: priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+
+ tag_type = __builtin__.property(_get_tag_type)
+ priority = __builtin__.property(_get_priority)
+
+
+ _pyangbind_elements = OrderedDict([('tag_type', tag_type), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..332a6026574b5c48fcc2d103f24fbbc3da2b2ab3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_end(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-end. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-end'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-end']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..37028d9bfc5a0c01683aa7e53f7a6b574d6a3f42
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-end/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-end', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..162b896241b326516b2a2d5261f872ecfe29ffbf
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-end/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-end', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..334475e0d1a9680a9b58e7c939a59ce7431c6db9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_start(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-start. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-start'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-start']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..7c384d8f7a786c4d542d4c36dc4f340d1ec0d3c9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-start/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-start', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..612e7141b0b4a8e877b2769cc353c653486113db
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-start/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-start', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..12f872b1f11d4f08571e87a68731c62b60ef8811
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class label_step(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-step. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_step',)
+
+ _yang_name = 'label-step'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-step']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/generic (int32)
+
+ YANG Description: Label range step.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/generic (int32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Label range step.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with int32""",
+ 'defined-type': "int32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn (container)
+
+ YANG Description: Label step for OTN
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label step for OTN
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_eth_step(self):
+ """
+ Getter method for eth_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/eth_step (uint16)
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ return self.__eth_step
+
+ def _set_eth_step(self, v, load=False):
+ """
+ Setter method for eth_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/eth_step (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_step() directly.
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_step must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__eth_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_step(self):
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ eth_step = __builtin__.property(_get_eth_step)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_step']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_step', eth_step), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f53bda83992147e406598acc77da79e6a9cd51a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-step/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label step for OTN
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-step', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..84ed14bf97bc2f6ca26fee89b43061f9fd0e2334
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/otn-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label range information for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__range_type','__tsg','__odu_type_list','__priority',)
+
+ _yang_name = 'otn-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'otn-label-range']
+
+ def _get_range_type(self):
+ """
+ Getter method for range_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ return self.__range_type
+
+ def _set_range_type(self, v, load=False):
+ """
+ Setter method for range_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_type() directly.
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_type must be of a type compatible with otn-label-range-type""",
+ 'defined-type': "ietf-otn-topology:otn-label-range-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)""",
+ })
+
+ self.__range_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_type(self):
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_odu_type_list(self):
+ """
+ Getter method for odu_type_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ return self.__odu_type_list
+
+ def _set_odu_type_list(self, v, load=False):
+ """
+ Setter method for odu_type_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type_list() directly.
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type_list must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__odu_type_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type_list(self):
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+
+ range_type = __builtin__.property(_get_range_type)
+ tsg = __builtin__.property(_get_tsg)
+ odu_type_list = __builtin__.property(_get_odu_type_list)
+ priority = __builtin__.property(_get_priority)
+
+
+ _pyangbind_elements = OrderedDict([('range_type', range_type), ('tsg', tsg), ('odu_type_list', odu_type_list), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0660881e28b783a340f6606fea9afba596749800
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/__init__.py
@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import primary_path
+from . import backup_path
+from . import tunnel_termination_points
+from . import tunnels
+class underlay(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__enabled','__primary_path','__backup_path','__protection_type','__tunnel_termination_points','__tunnels',)
+
+ _yang_name = 'underlay'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay']
+
+ def _get_enabled(self):
+ """
+ Getter method for enabled, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/enabled (boolean)
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ return self.__enabled
+
+ def _set_enabled(self, v, load=False):
+ """
+ Setter method for enabled, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/enabled (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_enabled is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_enabled() directly.
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """enabled must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)""",
+ })
+
+ self.__enabled = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_enabled(self):
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+
+ def _get_primary_path(self):
+ """
+ Getter method for primary_path, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path (container)
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ return self.__primary_path
+
+ def _set_primary_path(self, v, load=False):
+ """
+ Setter method for primary_path, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_primary_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_primary_path() directly.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """primary_path must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__primary_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_primary_path(self):
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_backup_path(self):
+ """
+ Getter method for backup_path, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path (list)
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ return self.__backup_path
+
+ def _set_backup_path(self, v, load=False):
+ """
+ Setter method for backup_path, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_backup_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_backup_path() directly.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """backup_path must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__backup_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_backup_path(self):
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_protection_type(self):
+ """
+ Getter method for protection_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/protection_type (identityref)
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ return self.__protection_type
+
+ def _set_protection_type(self, v, load=False):
+ """
+ Setter method for protection_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/protection_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_protection_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_protection_type() directly.
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """protection_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__protection_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_protection_type(self):
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_tunnel_termination_points(self):
+ """
+ Getter method for tunnel_termination_points, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points (container)
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ return self.__tunnel_termination_points
+
+ def _set_tunnel_termination_points(self, v, load=False):
+ """
+ Setter method for tunnel_termination_points, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_termination_points is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_termination_points() directly.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_termination_points must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__tunnel_termination_points = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_termination_points(self):
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_tunnels(self):
+ """
+ Getter method for tunnels, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels (container)
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ return self.__tunnels
+
+ def _set_tunnels(self, v, load=False):
+ """
+ Setter method for tunnels, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnels is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnels() directly.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnels must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__tunnels = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnels(self):
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ enabled = __builtin__.property(_get_enabled)
+ primary_path = __builtin__.property(_get_primary_path)
+ backup_path = __builtin__.property(_get_backup_path)
+ protection_type = __builtin__.property(_get_protection_type)
+ tunnel_termination_points = __builtin__.property(_get_tunnel_termination_points)
+ tunnels = __builtin__.property(_get_tunnels)
+
+
+ _pyangbind_elements = OrderedDict([('enabled', enabled), ('primary_path', primary_path), ('backup_path', backup_path), ('protection_type', protection_type), ('tunnel_termination_points', tunnel_termination_points), ('tunnels', tunnels), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e6da0327b6950bdd578cd2cc890a0ec097c053a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py
@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class backup_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/backup-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__network_ref','__path_element',)
+
+ _yang_name = 'backup-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/index (uint32)
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element (list)
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ network_ref = __builtin__.property(_get_network_ref)
+ path_element = __builtin__.property(_get_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('index', index), ('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..0e6bea8896fa5f3727db9b64111d928a2379b296
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/__init__.py
@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ path_element_id = __builtin__.property(_get_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2245d0d0e8d8c9c9bf932710b86966781ee377e7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fc0b539a612836fa7eb19f48cf7ec6e6d2eebd6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ed428029fc87f2785219c0de6190431190da50b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..242d6f3f26a1fca1fd0985db7a4b0ecd3cd3fa9d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6c47d4644ff1e8e6dbc3b5422b039b024780012
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba3dfc1f6132e0eae9787117f7147932e0cdb340
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5d313c9bba771f10a758ef1e31743617b93da4f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9efabfdc9833d3db3530bf4bc67801e8de97d09a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class primary_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/primary-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref','__path_element',)
+
+ _yang_name = 'primary-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element (list)
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ network_ref = __builtin__.property(_get_network_ref)
+ path_element = __builtin__.property(_get_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..c680af6e0cbb613d71b8eb8896295cdbeef0fabc
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/__init__.py
@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ path_element_id = __builtin__.property(_get_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..33f85e5281febfd6058e42db3c836b9fc230f533
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6cb0c9c11a2e435e7fcf1c672056a63d8e81606a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..04bb5f8c62618ae918ebff9c8eb0e03069bc41b7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0b0c85c53b809acc7e6c4300a557335aef6dca8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc4a1ad284407efff0c694b6f25dc14134a1127f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f6120bd56e1d699d796b29a921ac4cea947bb7d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f75c01074c5ce8e457f5e725599b90212576766
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe1f4b85508ac28b5a0f20bb1ea55bd1332d446a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel_termination_points(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/tunnel-termination-points. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__source','__destination',)
+
+ _yang_name = 'tunnel-termination-points'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'tunnel-termination-points']
+
+ def _get_source(self):
+ """
+ Getter method for source, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/source (binary)
+
+ YANG Description: Source TTP identifier.
+ """
+ return self.__source
+
+ def _set_source(self, v, load=False):
+ """
+ Setter method for source, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/source (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_source() directly.
+
+ YANG Description: Source TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """source must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)""",
+ })
+
+ self.__source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_source(self):
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+
+
+ def _get_destination(self):
+ """
+ Getter method for destination, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/destination (binary)
+
+ YANG Description: Destination TTP identifier.
+ """
+ return self.__destination
+
+ def _set_destination(self, v, load=False):
+ """
+ Setter method for destination, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/destination (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_destination is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_destination() directly.
+
+ YANG Description: Destination TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """destination must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)""",
+ })
+
+ self.__destination = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_destination(self):
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+
+ source = __builtin__.property(_get_source)
+ destination = __builtin__.property(_get_destination)
+
+
+ _pyangbind_elements = OrderedDict([('source', source), ('destination', destination), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0493843c740539cbe3763507f281d8120730bdb6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py
@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tunnel
+class tunnels(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/tunnels. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__sharing','__tunnel',)
+
+ _yang_name = 'tunnels'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'tunnels']
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+
+ def _get_tunnel(self):
+ """
+ Getter method for tunnel, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel (list)
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ return self.__tunnel
+
+ def _set_tunnel(self, v, load=False):
+ """
+ Setter method for tunnel, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel() directly.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__tunnel = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel(self):
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ sharing = __builtin__.property(_get_sharing)
+ tunnel = __builtin__.property(_get_tunnel)
+
+
+ _pyangbind_elements = OrderedDict([('sharing', sharing), ('tunnel', tunnel), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bade453763a51c761470543982308e483db615b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/connectivity-matrix/underlay/tunnels/tunnel. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tunnel_name','__sharing',)
+
+ _yang_name = 'tunnel'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'tunnels', 'tunnel']
+
+ def _get_tunnel_name(self):
+ """
+ Getter method for tunnel_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/tunnel_name (string)
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ return self.__tunnel_name
+
+ def _set_tunnel_name(self, v, load=False):
+ """
+ Setter method for tunnel_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/tunnel_name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_name() directly.
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__tunnel_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_name(self):
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+ tunnel_name = __builtin__.property(_get_tunnel_name)
+ sharing = __builtin__.property(_get_sharing)
+
+
+ _pyangbind_elements = OrderedDict([('tunnel_name', tunnel_name), ('sharing', sharing), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d7414731add908d5a234b2d980bc2c34f2c199e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restriction
+class label_restrictions(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The label restrictions container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__label_restriction',)
+
+ _yang_name = 'label-restrictions'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions']
+
+ def _get_label_restriction(self):
+ """
+ Getter method for label_restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction (list)
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ return self.__label_restriction
+
+ def _set_label_restriction(self, v, load=False):
+ """
+ Setter method for label_restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restriction() directly.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restriction must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__label_restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restriction(self):
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ label_restriction = __builtin__.property(_get_label_restriction)
+
+
+ _pyangbind_elements = OrderedDict([('label_restriction', label_restriction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..39cb5bdabbe35e56a81c00f4ec938e75f1d83fcd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/__init__.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_start
+from . import label_end
+from . import label_step
+from . import otn_label_range
+from . import ethernet_label_range
+class label_restriction(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restriction','__index','__label_start','__label_end','__label_step','__range_bitmap','__otn_label_range','__ethernet_label_range',)
+
+ _yang_name = 'label-restriction'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction']
+
+ def _get_restriction(self):
+ """
+ Getter method for restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/restriction (enumeration)
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ return self.__restriction
+
+ def _set_restriction(self, v, load=False):
+ """
+ Setter method for restriction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/restriction (enumeration)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restriction() directly.
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restriction must be of a type compatible with enumeration""",
+ 'defined-type': "ietf-te-topology:enumeration",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)""",
+ })
+
+ self.__restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restriction(self):
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=False)
+
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/index (uint32)
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_label_start(self):
+ """
+ Getter method for label_start, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start (container)
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ return self.__label_start
+
+ def _set_label_start(self, v, load=False):
+ """
+ Setter method for label_start, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_start is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_start() directly.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_start must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_start = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_start(self):
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_end(self):
+ """
+ Getter method for label_end, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end (container)
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ return self.__label_end
+
+ def _set_label_end(self, v, load=False):
+ """
+ Setter method for label_end, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_end is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_end() directly.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_end must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_end = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_end(self):
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_step(self):
+ """
+ Getter method for label_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step (container)
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ return self.__label_step
+
+ def _set_label_step(self, v, load=False):
+ """
+ Setter method for label_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_step() directly.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_step must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_step(self):
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_range_bitmap(self):
+ """
+ Getter method for range_bitmap, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ return self.__range_bitmap
+
+ def _set_range_bitmap(self, v, load=False):
+ """
+ Setter method for range_bitmap, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_bitmap is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_bitmap() directly.
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_bitmap must be of a type compatible with yang:hex-string""",
+ 'defined-type': "yang:hex-string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)""",
+ })
+
+ self.__range_bitmap = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_bitmap(self):
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=False)
+
+
+ def _get_otn_label_range(self):
+ """
+ Getter method for otn_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range (container)
+
+ YANG Description: Label range information for OTN.
+ """
+ return self.__otn_label_range
+
+ def _set_otn_label_range(self, v, load=False):
+ """
+ Setter method for otn_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_label_range() directly.
+
+ YANG Description: Label range information for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_label_range(self):
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_ethernet_label_range(self):
+ """
+ Getter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range (container)
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ return self.__ethernet_label_range
+
+ def _set_ethernet_label_range(self, v, load=False):
+ """
+ Setter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ethernet_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ethernet_label_range() directly.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ethernet_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__ethernet_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ethernet_label_range(self):
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=False)
+
+ restriction = __builtin__.property(_get_restriction)
+ index = __builtin__.property(_get_index)
+ label_start = __builtin__.property(_get_label_start)
+ label_end = __builtin__.property(_get_label_end)
+ label_step = __builtin__.property(_get_label_step)
+ range_bitmap = __builtin__.property(_get_range_bitmap)
+ otn_label_range = __builtin__.property(_get_otn_label_range)
+ ethernet_label_range = __builtin__.property(_get_ethernet_label_range)
+
+
+ _pyangbind_elements = OrderedDict([('restriction', restriction), ('index', index), ('label_start', label_start), ('label_end', label_end), ('label_step', label_step), ('range_bitmap', range_bitmap), ('otn_label_range', otn_label_range), ('ethernet_label_range', ethernet_label_range), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cfb573c3d6407b1d27f175d7a3fb6e0909fe780
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ethernet_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction/ethernet-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tag_type','__priority',)
+
+ _yang_name = 'ethernet-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'ethernet-label-range']
+
+ def _get_tag_type(self):
+ """
+ Getter method for tag_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+
+ YANG Description: VLAN tag type.
+ """
+ return self.__tag_type
+
+ def _set_tag_type(self, v, load=False):
+ """
+ Setter method for tag_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tag_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tag_type() directly.
+
+ YANG Description: VLAN tag type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tag_type must be of a type compatible with etht-types:eth-tag-type""",
+ 'defined-type': "etht-types:eth-tag-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)""",
+ })
+
+ self.__tag_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tag_type(self):
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=False)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+
+ YANG Description: priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=False)
+
+ tag_type = __builtin__.property(_get_tag_type)
+ priority = __builtin__.property(_get_priority)
+
+
+ _pyangbind_elements = OrderedDict([('tag_type', tag_type), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c503e2b257aeee411091790f42ec349eee349c0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_end(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction/label-end. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-end'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-end']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..de17adeb4459dd104de1cde30c405cf5a023583b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction/label-end/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-end', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..459dceb1d30e33d8699064985129d362e7a114b3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction/label-end/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-end', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a8e4c4dccf50bade3f069f5f589d4bc274aa444
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_start(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction/label-start. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-start'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-start']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..1f66e6dae904e15a1f49b0c58b5b64a535a5e33f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction/label-start/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-start', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad22f6a1525b4023d92360870cbe758a06dc3566
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction/label-start/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-start', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..42085f541bcef1d3b09ca52af3574985b0df17a7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class label_step(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction/label-step. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_step',)
+
+ _yang_name = 'label-step'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-step']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/generic (int32)
+
+ YANG Description: Label range step.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/generic (int32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Label range step.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with int32""",
+ 'defined-type': "int32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/otn (container)
+
+ YANG Description: Label step for OTN
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label step for OTN
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_eth_step(self):
+ """
+ Getter method for eth_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/eth_step (uint16)
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ return self.__eth_step
+
+ def _set_eth_step(self, v, load=False):
+ """
+ Setter method for eth_step, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/eth_step (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_step() directly.
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_step must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__eth_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_step(self):
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ eth_step = __builtin__.property(_get_eth_step)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_step']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_step', eth_step), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..138aacf1b355262ce5289a44e237e6a3b9d21278
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction/label-step/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label step for OTN
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-step', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ ts = __builtin__.property(_get_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b951f71cba2de3f0fe8ee95b5f197ca2dcd856a7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/label-restrictions/label-restriction/otn-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label range information for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__range_type','__tsg','__odu_type_list','__priority',)
+
+ _yang_name = 'otn-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'otn-label-range']
+
+ def _get_range_type(self):
+ """
+ Getter method for range_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ return self.__range_type
+
+ def _set_range_type(self, v, load=False):
+ """
+ Setter method for range_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_type() directly.
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_type must be of a type compatible with otn-label-range-type""",
+ 'defined-type': "ietf-otn-topology:otn-label-range-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)""",
+ })
+
+ self.__range_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_type(self):
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_odu_type_list(self):
+ """
+ Getter method for odu_type_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ return self.__odu_type_list
+
+ def _set_odu_type_list(self, v, load=False):
+ """
+ Setter method for odu_type_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type_list() directly.
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type_list must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__odu_type_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type_list(self):
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=False)
+
+ range_type = __builtin__.property(_get_range_type)
+ tsg = __builtin__.property(_get_tsg)
+ odu_type_list = __builtin__.property(_get_odu_type_list)
+ priority = __builtin__.property(_get_priority)
+
+
+ _pyangbind_elements = OrderedDict([('range_type', range_type), ('tsg', tsg), ('odu_type_list', odu_type_list), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a561f8138342940ab3183618f6add0ee154b46d8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/__init__.py
@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import optimization_metric
+from . import tiebreakers
+from . import objective_function
+class optimizations(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__optimization_metric','__tiebreakers','__objective_function',)
+
+ _yang_name = 'optimizations'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations']
+
+ def _get_optimization_metric(self):
+ """
+ Getter method for optimization_metric, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__optimization_metric
+
+ def _set_optimization_metric(self, v, load=False):
+ """
+ Setter method for optimization_metric, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimization_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimization_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimization_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__optimization_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimization_metric(self):
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_tiebreakers(self):
+ """
+ Getter method for tiebreakers, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers (container)
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ return self.__tiebreakers
+
+ def _set_tiebreakers(self, v, load=False):
+ """
+ Setter method for tiebreakers, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreakers is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreakers() directly.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreakers must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__tiebreakers = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreakers(self):
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_objective_function(self):
+ """
+ Getter method for objective_function, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/objective_function (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__objective_function
+
+ def _set_objective_function(self, v, load=False):
+ """
+ Setter method for objective_function, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/objective_function (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__objective_function = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function(self):
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ optimization_metric = __builtin__.property(_get_optimization_metric)
+ tiebreakers = __builtin__.property(_get_tiebreakers)
+ objective_function = __builtin__.property(_get_objective_function)
+
+ __choices__ = {'algorithm': {'metric': ['optimization_metric', 'tiebreakers'], 'objective-function': ['objective_function']}}
+ _pyangbind_elements = OrderedDict([('optimization_metric', optimization_metric), ('tiebreakers', tiebreakers), ('objective_function', objective_function), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/objective_function/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/objective_function/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5742ea3002afa82d4263d295667918e31d3ffec
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/objective_function/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class objective_function(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/objective-function. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__objective_function_type',)
+
+ _yang_name = 'objective-function'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'objective-function']
+
+ def _get_objective_function_type(self):
+ """
+ Getter method for objective_function_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/objective_function/objective_function_type (identityref)
+
+ YANG Description: Objective function entry.
+ """
+ return self.__objective_function_type
+
+ def _set_objective_function_type(self, v, load=False):
+ """
+ Setter method for objective_function_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/objective_function/objective_function_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function_type() directly.
+
+ YANG Description: Objective function entry.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__objective_function_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function_type(self):
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+ objective_function_type = __builtin__.property(_get_objective_function_type)
+
+ __choices__ = {'algorithm': {'objective-function': ['objective_function_type']}}
+ _pyangbind_elements = OrderedDict([('objective_function_type', objective_function_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..de3425526bf502146628f83fc80526b1867f3ff0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/__init__.py
@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import explicit_route_exclude_objects
+from . import explicit_route_include_objects
+class optimization_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__weight','__explicit_route_exclude_objects','__explicit_route_include_objects',)
+
+ _yang_name = 'optimization-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/metric_type (identityref)
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_weight(self):
+ """
+ Getter method for weight, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/weight (uint8)
+
+ YANG Description: TE path metric normalization weight.
+ """
+ return self.__weight
+
+ def _set_weight(self, v, load=False):
+ """
+ Setter method for weight, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/weight (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_weight is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_weight() directly.
+
+ YANG Description: TE path metric normalization weight.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """weight must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__weight = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_weight(self):
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+
+
+ def _get_explicit_route_exclude_objects(self):
+ """
+ Getter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ return self.__explicit_route_exclude_objects
+
+ def _set_explicit_route_exclude_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_exclude_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_exclude_objects() directly.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_exclude_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__explicit_route_exclude_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_exclude_objects(self):
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_explicit_route_include_objects(self):
+ """
+ Getter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects (container)
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ return self.__explicit_route_include_objects
+
+ def _set_explicit_route_include_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_include_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_include_objects() directly.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_include_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__explicit_route_include_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_include_objects(self):
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ metric_type = __builtin__.property(_get_metric_type)
+ weight = __builtin__.property(_get_weight)
+ explicit_route_exclude_objects = __builtin__.property(_get_explicit_route_exclude_objects)
+ explicit_route_include_objects = __builtin__.property(_get_explicit_route_include_objects)
+
+ __choices__ = {'algorithm': {'metric': ['metric_type', 'weight', 'explicit_route_exclude_objects', 'explicit_route_include_objects']}}
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('weight', weight), ('explicit_route_exclude_objects', explicit_route_exclude_objects), ('explicit_route_include_objects', explicit_route_include_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6df6741a983f17df9525a546bcc24f6392f9a5f8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_exclude_object
+class explicit_route_exclude_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_exclude_object',)
+
+ _yang_name = 'explicit-route-exclude-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects']
+
+ def _get_route_object_exclude_object(self):
+ """
+ Getter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ return self.__route_object_exclude_object
+
+ def _set_route_object_exclude_object(self, v, load=False):
+ """
+ Setter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_exclude_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_exclude_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_exclude_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__route_object_exclude_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_exclude_object(self):
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ route_object_exclude_object = __builtin__.property(_get_route_object_exclude_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_exclude_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_exclude_object', route_object_exclude_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..66415fe3b314536e9002f7a0276f0ef532da821c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
@@ -0,0 +1,365 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+from . import srlg
+class route_object_exclude_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop','__srlg',)
+
+ _yang_name = 'route-object-exclude-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+
+ YANG Description: SRLG container.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+ srlg = __builtin__.property(_get_srlg)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop'], 'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..267567f74521ce6b6ae6ba71a95183bebc1823b8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfb42f946181c167785c0e3b563f8144ebd893c5
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..22dc3125e462c1a4216a16adbafed71103cdc1dd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..68706941449f6359d729a9ca9a6062eebc717c72
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5981ace6489abb54c1b6951a02ab855ba6d8c09e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e42736cbe14ffb31bd0d0d2cc3a3e4c321b4804d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fcd5a3c7e35e6bcad9f087d0c9b69c0ba3ed3ce7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py
@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class srlg(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/srlg. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: SRLG container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__srlg',)
+
+ _yang_name = 'srlg'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__srlg = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'srlg']
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/srlg (uint32)
+
+ YANG Description: SRLG value.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/srlg (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+ srlg = __builtin__.property(_get_srlg)
+
+ __choices__ = {'type': {'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..487e25e737837b9b9475ef95d6ceec25c1d81744
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..06b2702da984d8ed2355683f3603f538efc430c0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_include_object
+class explicit_route_include_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_include_object',)
+
+ _yang_name = 'explicit-route-include-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_include_object = YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects']
+
+ def _get_route_object_include_object(self):
+ """
+ Getter method for route_object_include_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object (list)
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ return self.__route_object_include_object
+
+ def _set_route_object_include_object(self, v, load=False):
+ """
+ Setter method for route_object_include_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_include_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_include_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_include_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__route_object_include_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_include_object(self):
+ self.__route_object_include_object = YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ route_object_include_object = __builtin__.property(_get_route_object_include_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_include_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_include_object', route_object_include_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b7b9e7e8bae1e6642dbab091b56fafaafaa9382
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py
@@ -0,0 +1,325 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class route_object_include_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'route-object-include-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a30ba2c884047e7c1188f2db95c140614bad05d0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5adb8788e175b1dee82e2e76374fb88c16a4f7d6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9494b4fda980a14f82d2595fb76717aba610b2c4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..030f51b1f4b7cfd10ef486db089420efe0635d75
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..50a4caad878397da24119fbe69d64d45bced9a14
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6952ba89be848862056de6f9baed16e7ef90df0e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4ec3b3a951b016b6fb8df74c6e6e4ba551fbcb9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3357913dd0b1bbfc42da56f04599ff3c4a2372da
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tiebreaker
+class tiebreakers(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/tiebreakers. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tiebreaker',)
+
+ _yang_name = 'tiebreakers'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tiebreaker = YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'tiebreakers']
+
+ def _get_tiebreaker(self):
+ """
+ Getter method for tiebreaker, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers/tiebreaker (list)
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ return self.__tiebreaker
+
+ def _set_tiebreaker(self, v, load=False):
+ """
+ Setter method for tiebreaker, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers/tiebreaker (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreaker is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreaker() directly.
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreaker must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__tiebreaker = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreaker(self):
+ self.__tiebreaker = YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ tiebreaker = __builtin__.property(_get_tiebreaker)
+
+ __choices__ = {'algorithm': {'metric': ['tiebreaker']}}
+ _pyangbind_elements = OrderedDict([('tiebreaker', tiebreaker), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers/tiebreaker/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers/tiebreaker/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4478acced1f4548ce3090a00bef95a37125c4386
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers/tiebreaker/__init__.py
@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tiebreaker(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/optimizations/tiebreakers/tiebreaker. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tiebreaker_type',)
+
+ _yang_name = 'tiebreaker'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tiebreaker_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'optimizations', 'tiebreakers', 'tiebreaker']
+
+ def _get_tiebreaker_type(self):
+ """
+ Getter method for tiebreaker_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers/tiebreaker/tiebreaker_type (identityref)
+
+ YANG Description: Identifies an entry in the list of tiebreakers.
+ """
+ return self.__tiebreaker_type
+
+ def _set_tiebreaker_type(self, v, load=False):
+ """
+ Setter method for tiebreaker_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/tiebreakers/tiebreaker/tiebreaker_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreaker_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreaker_type() directly.
+
+ YANG Description: Identifies an entry in the list of tiebreakers.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreaker_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tiebreaker_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreaker_type(self):
+ self.__tiebreaker_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+ tiebreaker_type = __builtin__.property(_get_tiebreaker_type)
+
+ __choices__ = {'algorithm': {'metric': ['tiebreaker_type']}}
+ _pyangbind_elements = OrderedDict([('tiebreaker_type', tiebreaker_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..74807897d04dcf0f8eb598293612b0e0447a003d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/__init__.py
@@ -0,0 +1,523 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+from . import path_metric_bounds
+from . import path_affinities_values
+from . import path_affinity_names
+from . import path_srlgs_lists
+from . import path_srlgs_names
+class path_constraints(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE named path constraints container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_bandwidth','__link_protection','__setup_priority','__hold_priority','__signaling_type','__path_metric_bounds','__path_affinities_values','__path_affinity_names','__path_srlgs_lists','__path_srlgs_names','__disjointness',)
+
+ _yang_name = 'path-constraints'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__link_protection = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__setup_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ self.__hold_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ self.__signaling_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__path_metric_bounds = YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__disjointness = YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints']
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_link_protection(self):
+ """
+ Getter method for link_protection, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/link_protection (identityref)
+
+ YANG Description: Link protection type required for the links included
+in the computed path.
+ """
+ return self.__link_protection
+
+ def _set_link_protection(self, v, load=False):
+ """
+ Setter method for link_protection, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/link_protection (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_protection is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_protection() directly.
+
+ YANG Description: Link protection type required for the links included
+in the computed path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_protection must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__link_protection = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_protection(self):
+ self.__link_protection = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_setup_priority(self):
+ """
+ Getter method for setup_priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/setup_priority (uint8)
+
+ YANG Description: TE LSP requested setup priority.
+ """
+ return self.__setup_priority
+
+ def _set_setup_priority(self, v, load=False):
+ """
+ Setter method for setup_priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/setup_priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_setup_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_setup_priority() directly.
+
+ YANG Description: TE LSP requested setup priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """setup_priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__setup_priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_setup_priority(self):
+ self.__setup_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+
+
+ def _get_hold_priority(self):
+ """
+ Getter method for hold_priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/hold_priority (uint8)
+
+ YANG Description: TE LSP requested hold priority.
+ """
+ return self.__hold_priority
+
+ def _set_hold_priority(self, v, load=False):
+ """
+ Setter method for hold_priority, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/hold_priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hold_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hold_priority() directly.
+
+ YANG Description: TE LSP requested hold priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hold_priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)""",
+ })
+
+ self.__hold_priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hold_priority(self):
+ self.__hold_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=False)
+
+
+ def _get_signaling_type(self):
+ """
+ Getter method for signaling_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/signaling_type (identityref)
+
+ YANG Description: TE tunnel path signaling type.
+ """
+ return self.__signaling_type
+
+ def _set_signaling_type(self, v, load=False):
+ """
+ Setter method for signaling_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/signaling_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_signaling_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_signaling_type() directly.
+
+ YANG Description: TE tunnel path signaling type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """signaling_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__signaling_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_signaling_type(self):
+ self.__signaling_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_path_metric_bounds(self):
+ """
+ Getter method for path_metric_bounds, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds (container)
+
+ YANG Description: TE path metric bounds container.
+ """
+ return self.__path_metric_bounds
+
+ def _set_path_metric_bounds(self, v, load=False):
+ """
+ Setter method for path_metric_bounds, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric_bounds is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric_bounds() directly.
+
+ YANG Description: TE path metric bounds container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric_bounds must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_metric_bounds = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric_bounds(self):
+ self.__path_metric_bounds = YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_affinities_values(self):
+ """
+ Getter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values (container)
+
+ YANG Description: Path affinities represented as values.
+ """
+ return self.__path_affinities_values
+
+ def _set_path_affinities_values(self, v, load=False):
+ """
+ Setter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_values() directly.
+
+ YANG Description: Path affinities represented as values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_values must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinities_values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_values(self):
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_affinity_names(self):
+ """
+ Getter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names (container)
+
+ YANG Description: Path affinities represented as names.
+ """
+ return self.__path_affinity_names
+
+ def _set_path_affinity_names(self, v, load=False):
+ """
+ Setter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_names() directly.
+
+ YANG Description: Path affinities represented as names.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinity_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_names(self):
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_lists(self):
+ """
+ Getter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists (container)
+
+ YANG Description: Path SRLG properties container.
+ """
+ return self.__path_srlgs_lists
+
+ def _set_path_srlgs_lists(self, v, load=False):
+ """
+ Setter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_lists is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_lists() directly.
+
+ YANG Description: Path SRLG properties container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_lists must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_lists = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_lists(self):
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_names(self):
+ """
+ Getter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names (container)
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ return self.__path_srlgs_names
+
+ def _set_path_srlgs_names(self, v, load=False):
+ """
+ Setter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_names() directly.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_names(self):
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_disjointness(self):
+ """
+ Getter method for disjointness, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/disjointness (te-path-disjointness)
+
+ YANG Description: The type of resource disjointness.
+When configured for a primary path, the disjointness level
+applies to all secondary LSPs. When configured for a
+secondary path, the disjointness level overrides the level
+configured for the primary path.
+ """
+ return self.__disjointness
+
+ def _set_disjointness(self, v, load=False):
+ """
+ Setter method for disjointness, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/disjointness (te-path-disjointness)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_disjointness is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_disjointness() directly.
+
+ YANG Description: The type of resource disjointness.
+When configured for a primary path, the disjointness level
+applies to all secondary LSPs. When configured for a
+secondary path, the disjointness level overrides the level
+configured for the primary path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """disjointness must be of a type compatible with te-path-disjointness""",
+ 'defined-type': "ietf-te-topology:te-path-disjointness",
+ 'generated-type': """YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=False)""",
+ })
+
+ self.__disjointness = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_disjointness(self):
+ self.__disjointness = YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=False)
+
+ te_bandwidth = __builtin__.property(_get_te_bandwidth)
+ link_protection = __builtin__.property(_get_link_protection)
+ setup_priority = __builtin__.property(_get_setup_priority)
+ hold_priority = __builtin__.property(_get_hold_priority)
+ signaling_type = __builtin__.property(_get_signaling_type)
+ path_metric_bounds = __builtin__.property(_get_path_metric_bounds)
+ path_affinities_values = __builtin__.property(_get_path_affinities_values)
+ path_affinity_names = __builtin__.property(_get_path_affinity_names)
+ path_srlgs_lists = __builtin__.property(_get_path_srlgs_lists)
+ path_srlgs_names = __builtin__.property(_get_path_srlgs_names)
+ disjointness = __builtin__.property(_get_disjointness)
+
+
+ _pyangbind_elements = OrderedDict([('te_bandwidth', te_bandwidth), ('link_protection', link_protection), ('setup_priority', setup_priority), ('hold_priority', hold_priority), ('signaling_type', signaling_type), ('path_metric_bounds', path_metric_bounds), ('path_affinities_values', path_affinities_values), ('path_affinity_names', path_affinity_names), ('path_srlgs_lists', path_srlgs_lists), ('path_srlgs_names', path_srlgs_names), ('disjointness', disjointness), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f42a2ac965c4fa925ad1564a0c10ecfb740670a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinities_value
+class path_affinities_values(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-affinities-values. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as values.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinities_value',)
+
+ _yang_name = 'path-affinities-values'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-affinities-values']
+
+ def _get_path_affinities_value(self):
+ """
+ Getter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinities_value
+
+ def _set_path_affinities_value(self, v, load=False):
+ """
+ Setter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_value() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_value must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinities_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_value(self):
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinities_value = __builtin__.property(_get_path_affinities_value)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinities_value', path_affinities_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..cd1a2c6ed9f2b3f51b99eece2887f868581e32dc
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_affinities_value(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-affinities-values/path-affinities-value. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__value',)
+
+ _yang_name = 'path-affinities-value'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-affinities-values', 'path-affinities-value']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/value (admin-groups)
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/value (admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with admin-groups""",
+ 'defined-type': "ietf-te-topology:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ value = __builtin__.property(_get_value)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7f5be85bb568b148da298ab2f818f682b5ddc88
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinity_name
+class path_affinity_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-affinity-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as names.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinity_name',)
+
+ _yang_name = 'path-affinity-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-affinity-names']
+
+ def _get_path_affinity_name(self):
+ """
+ Getter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinity_name
+
+ def _set_path_affinity_name(self, v, load=False):
+ """
+ Setter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_name() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_name(self):
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinity_name = __builtin__.property(_get_path_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinity_name', path_affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..67a1ea760eb104298fb4c25115dc5f8fe023984e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/__init__.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import affinity_name
+class path_affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-affinity-names/path-affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__affinity_name',)
+
+ _yang_name = 'path-affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-affinity-names', 'path-affinity-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_affinity_name(self):
+ """
+ Getter method for affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name (list)
+
+ YANG Description: List of named affinities.
+ """
+ return self.__affinity_name
+
+ def _set_affinity_name(self, v, load=False):
+ """
+ Setter method for affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_affinity_name() directly.
+
+ YANG Description: List of named affinities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_affinity_name(self):
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ affinity_name = __builtin__.property(_get_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('affinity_name', affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..e97d6d57e18426e05dd89e861117a2a2a45beb45
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-affinity-names/path-affinity-name/affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__name',)
+
+ _yang_name = 'affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-affinity-names', 'path-affinity-name', 'affinity-name']
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/name (string)
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ name = __builtin__.property(_get_name)
+
+
+ _pyangbind_elements = OrderedDict([('name', name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..92e0cb519c0177c3546d84266e0e3e52d26e02e1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_metric_bound
+class path_metric_bounds(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-metric-bounds. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric bounds container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_metric_bound',)
+
+ _yang_name = 'path-metric-bounds'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_metric_bound = YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-metric-bounds']
+
+ def _get_path_metric_bound(self):
+ """
+ Getter method for path_metric_bound, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound (list)
+
+ YANG Description: List of TE path metric bounds.
+ """
+ return self.__path_metric_bound
+
+ def _set_path_metric_bound(self, v, load=False):
+ """
+ Setter method for path_metric_bound, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric_bound is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric_bound() directly.
+
+ YANG Description: List of TE path metric bounds.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric_bound must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_metric_bound = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric_bound(self):
+ self.__path_metric_bound = YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_metric_bound = __builtin__.property(_get_path_metric_bound)
+
+
+ _pyangbind_elements = OrderedDict([('path_metric_bound', path_metric_bound), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..74b7fca4e30b04b4713e4661b04e8fc25f1ceb0f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/__init__.py
@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_metric_bound(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-metric-bounds/path-metric-bound. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of TE path metric bounds.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__upper_bound',)
+
+ _yang_name = 'path-metric-bound'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__upper_bound = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-metric-bounds', 'path-metric-bound']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/metric_type (identityref)
+
+ YANG Description: Identifies an entry in the list of 'metric-type' items
+bound for the TE path.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies an entry in the list of 'metric-type' items
+bound for the TE path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_upper_bound(self):
+ """
+ Getter method for upper_bound, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/upper_bound (uint64)
+
+ YANG Description: Upper bound on the end-to-end TE path metric. A zero
+indicates an unbounded upper limit for the specific
+'metric-type'.
+ """
+ return self.__upper_bound
+
+ def _set_upper_bound(self, v, load=False):
+ """
+ Setter method for upper_bound, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/upper_bound (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_upper_bound is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_upper_bound() directly.
+
+ YANG Description: Upper bound on the end-to-end TE path metric. A zero
+indicates an unbounded upper limit for the specific
+'metric-type'.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """upper_bound must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__upper_bound = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_upper_bound(self):
+ self.__upper_bound = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ metric_type = __builtin__.property(_get_metric_type)
+ upper_bound = __builtin__.property(_get_upper_bound)
+
+
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('upper_bound', upper_bound), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c1eb4e15c50fb4b2b179a918715e3d1bff3da85
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_list
+class path_srlgs_lists(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-srlgs-lists. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path SRLG properties container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_list',)
+
+ _yang_name = 'path-srlgs-lists'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-srlgs-lists']
+
+ def _get_path_srlgs_list(self):
+ """
+ Getter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list (list)
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ return self.__path_srlgs_list
+
+ def _set_path_srlgs_list(self, v, load=False):
+ """
+ Setter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_list() directly.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_list must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_list(self):
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_list = __builtin__.property(_get_path_srlgs_list)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_list', path_srlgs_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..7ee7c8defc5c952669b20e50d97763f85e0c04bd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_list(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-srlgs-lists/path-srlgs-list. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__values',)
+
+ _yang_name = 'path-srlgs-list'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-srlgs-lists', 'path-srlgs-list']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_values(self):
+ """
+ Getter method for values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/values (srlg)
+
+ YANG Description: List of SRLG values.
+ """
+ return self.__values
+
+ def _set_values(self, v, load=False):
+ """
+ Setter method for values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/values (srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_values() directly.
+
+ YANG Description: List of SRLG values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """values must be of a type compatible with srlg""",
+ 'defined-type': "ietf-te-topology:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)""",
+ })
+
+ self.__values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_values(self):
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ values = __builtin__.property(_get_values)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('values', values), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..20ff89122cfb45e1661dc65ccc76397966048a27
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_name
+class path_srlgs_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-srlgs-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_name',)
+
+ _yang_name = 'path-srlgs-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-srlgs-names']
+
+ def _get_path_srlgs_name(self):
+ """
+ Getter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name (list)
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ return self.__path_srlgs_name
+
+ def _set_path_srlgs_name(self, v, load=False):
+ """
+ Setter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_name() directly.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_name(self):
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_name = __builtin__.property(_get_path_srlgs_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_name', path_srlgs_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..e04c9a2781da176ef3d1222c83f85681406e79a9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/path-srlgs-names/path-srlgs-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__names',)
+
+ _yang_name = 'path-srlgs-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'path-srlgs-names', 'path-srlgs-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_names(self):
+ """
+ Getter method for names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/names (string)
+
+ YANG Description: List of named SRLGs.
+ """
+ return self.__names
+
+ def _set_names(self, v, load=False):
+ """
+ Setter method for names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/names (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_names() directly.
+
+ YANG Description: List of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """names must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_names(self):
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ names = __builtin__.property(_get_names)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('names', names), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..04440580661e25de34ef575a3dfbbae674d36f17
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_bandwidth']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf1f3bd4cf63ab45b04b7246e08f9355ffa9beec
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/__init__.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist','__odtu_flex_type',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=False)
+
+
+ def _get_odtu_flex_type(self):
+ """
+ Getter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+set up along the underlay paths of these OTN
+connectivity matrices.
+ """
+ return self.__odtu_flex_type
+
+ def _set_odtu_flex_type(self, v, load=False):
+ """
+ Setter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odtu_flex_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odtu_flex_type() directly.
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+set up along the underlay paths of these OTN
+connectivity matrices.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odtu_flex_type must be of a type compatible with l1-types:odtu-flex-type""",
+ 'defined-type': "l1-types:odtu-flex-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=False)""",
+ })
+
+ self.__odtu_flex_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odtu_flex_type(self):
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=False)
+
+ odulist = __builtin__.property(_get_odulist)
+ odtu_flex_type = __builtin__.property(_get_odtu_flex_type)
+
+ __choices__ = {'technology': {'otn': ['odulist', 'odtu_flex_type']}}
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ('odtu_flex_type', odtu_flex_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e9960a676e9d864f505ae65a0d66de711d9b9cd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-constraints/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-constraints', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=False)
+
+ odu_type = __builtin__.property(_get_odu_type)
+ number = __builtin__.property(_get_number)
+ ts_number = __builtin__.property(_get_ts_number)
+
+ __choices__ = {'technology': {'otn': ['odu_type', 'number', 'ts_number']}}
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfb5797aa3d093195bd4cb1933b18ef5a5a577ff
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/__init__.py
@@ -0,0 +1,318 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_metric
+from . import path_affinities_values
+from . import path_affinity_names
+from . import path_srlgs_lists
+from . import path_srlgs_names
+from . import path_route_objects
+class path_properties(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The TE path properties.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_metric','__path_affinities_values','__path_affinity_names','__path_srlgs_lists','__path_srlgs_names','__path_route_objects',)
+
+ _yang_name = 'path-properties'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_metric = YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_route_objects = YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties']
+
+ def _get_path_metric(self):
+ """
+ Getter method for path_metric, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__path_metric
+
+ def _set_path_metric(self, v, load=False):
+ """
+ Setter method for path_metric, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric(self):
+ self.__path_metric = YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_path_affinities_values(self):
+ """
+ Getter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values (container)
+
+ YANG Description: Path affinities represented as values.
+ """
+ return self.__path_affinities_values
+
+ def _set_path_affinities_values(self, v, load=False):
+ """
+ Setter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_values() directly.
+
+ YANG Description: Path affinities represented as values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_values must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinities_values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_values(self):
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_affinity_names(self):
+ """
+ Getter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names (container)
+
+ YANG Description: Path affinities represented as names.
+ """
+ return self.__path_affinity_names
+
+ def _set_path_affinity_names(self, v, load=False):
+ """
+ Setter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_names() directly.
+
+ YANG Description: Path affinities represented as names.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinity_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_names(self):
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_lists(self):
+ """
+ Getter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists (container)
+
+ YANG Description: Path SRLG properties container.
+ """
+ return self.__path_srlgs_lists
+
+ def _set_path_srlgs_lists(self, v, load=False):
+ """
+ Setter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_lists is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_lists() directly.
+
+ YANG Description: Path SRLG properties container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_lists must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_lists = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_lists(self):
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_names(self):
+ """
+ Getter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names (container)
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ return self.__path_srlgs_names
+
+ def _set_path_srlgs_names(self, v, load=False):
+ """
+ Setter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_names() directly.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_names(self):
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_route_objects(self):
+ """
+ Getter method for path_route_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects (container)
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ return self.__path_route_objects
+
+ def _set_path_route_objects(self, v, load=False):
+ """
+ Setter method for path_route_objects, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_route_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_route_objects() directly.
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_route_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_route_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_route_objects(self):
+ self.__path_route_objects = YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ path_metric = __builtin__.property(_get_path_metric)
+ path_affinities_values = __builtin__.property(_get_path_affinities_values)
+ path_affinity_names = __builtin__.property(_get_path_affinity_names)
+ path_srlgs_lists = __builtin__.property(_get_path_srlgs_lists)
+ path_srlgs_names = __builtin__.property(_get_path_srlgs_names)
+ path_route_objects = __builtin__.property(_get_path_route_objects)
+
+
+ _pyangbind_elements = OrderedDict([('path_metric', path_metric), ('path_affinities_values', path_affinities_values), ('path_affinity_names', path_affinity_names), ('path_srlgs_lists', path_srlgs_lists), ('path_srlgs_names', path_srlgs_names), ('path_route_objects', path_route_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..88aefb9b671fbdd1c8720152972b52e5271fbf68
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinities_value
+class path_affinities_values(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-affinities-values. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as values.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinities_value',)
+
+ _yang_name = 'path-affinities-values'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-affinities-values']
+
+ def _get_path_affinities_value(self):
+ """
+ Getter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinities_value
+
+ def _set_path_affinities_value(self, v, load=False):
+ """
+ Setter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_value() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_value must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinities_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_value(self):
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinities_value = __builtin__.property(_get_path_affinities_value)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinities_value', path_affinities_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..92f7c32355251a17b249c68bc1e6ccf202951ddb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_affinities_value(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-affinities-values/path-affinities-value. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__value',)
+
+ _yang_name = 'path-affinities-value'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-affinities-values', 'path-affinities-value']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/value (admin-groups)
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/value (admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with admin-groups""",
+ 'defined-type': "ietf-te-topology:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ value = __builtin__.property(_get_value)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b9de5d168552bfa7fbc459f2c5205ebeba73ca7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinity_name
+class path_affinity_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-affinity-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as names.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinity_name',)
+
+ _yang_name = 'path-affinity-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-affinity-names']
+
+ def _get_path_affinity_name(self):
+ """
+ Getter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinity_name
+
+ def _set_path_affinity_name(self, v, load=False):
+ """
+ Setter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_name() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_name(self):
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinity_name = __builtin__.property(_get_path_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinity_name', path_affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..ae1ed41e1af5db040ceabf8a54508fed604daebe
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/__init__.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import affinity_name
+class path_affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-affinity-names/path-affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__affinity_name',)
+
+ _yang_name = 'path-affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-affinity-names', 'path-affinity-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_affinity_name(self):
+ """
+ Getter method for affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name (list)
+
+ YANG Description: List of named affinities.
+ """
+ return self.__affinity_name
+
+ def _set_affinity_name(self, v, load=False):
+ """
+ Setter method for affinity_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_affinity_name() directly.
+
+ YANG Description: List of named affinities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_affinity_name(self):
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ affinity_name = __builtin__.property(_get_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('affinity_name', affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..73aa7bee9ec3a83fb61ab5e3219952f8af45524b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-affinity-names/path-affinity-name/affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__name',)
+
+ _yang_name = 'affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-affinity-names', 'path-affinity-name', 'affinity-name']
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/name (string)
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ name = __builtin__.property(_get_name)
+
+
+ _pyangbind_elements = OrderedDict([('name', name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..71b3184bdcc6e82a69a7839b674e70a57f1e92a9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric/__init__.py
@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__accumulative_value',)
+
+ _yang_name = 'path-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__accumulative_value = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric/metric_type (identityref)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: TE path metric type.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_accumulative_value(self):
+ """
+ Getter method for accumulative_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric/accumulative_value (uint64)
+
+ YANG Description: TE path metric accumulative value.
+ """
+ return self.__accumulative_value
+
+ def _set_accumulative_value(self, v, load=False):
+ """
+ Setter method for accumulative_value, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric/accumulative_value (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_accumulative_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_accumulative_value() directly.
+
+ YANG Description: TE path metric accumulative value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """accumulative_value must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__accumulative_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_accumulative_value(self):
+ self.__accumulative_value = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ metric_type = __builtin__.property(_get_metric_type)
+ accumulative_value = __builtin__.property(_get_accumulative_value)
+
+
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('accumulative_value', accumulative_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b21cd85db7343db1d0f947229cd1d08910d6fb9f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_route_object
+class path_route_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-route-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_route_object',)
+
+ _yang_name = 'path-route-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_route_object = YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-route-objects']
+
+ def _get_path_route_object(self):
+ """
+ Getter method for path_route_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object (list)
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ return self.__path_route_object
+
+ def _set_path_route_object(self, v, load=False):
+ """
+ Setter method for path_route_object, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_route_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_route_object() directly.
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_route_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_route_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_route_object(self):
+ self.__path_route_object = YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_route_object = __builtin__.property(_get_path_route_object)
+
+
+ _pyangbind_elements = OrderedDict([('path_route_object', path_route_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..c2331faf9d4ed964e117e9a2bbc7d1d954f54248
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/__init__.py
@@ -0,0 +1,327 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_route_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-route-objects/path-route-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-route-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key
+values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key
+values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..86c07902e489a6b644175e85dfa9403080123188
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-route-objects/path-route-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..07d9666aeff4da55b1a95cf98bcdfa5c36c5ae28
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-route-objects/path-route-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1204a2ff489ba4a972aab5ea983aa0a736a420b8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-route-objects/path-route-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..874d8ed5f8beeaea05b47fa8354ab2b0fb293122
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-route-objects/path-route-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e41be3b4cf2553fa1abc7ba1b37299f045418107
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-route-objects/path-route-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb07641c0e179c250c88dff9fe363c1959ee12dd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-route-objects/path-route-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8eab3fc14c4aa1803298ceedfdd3f6c9047501c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-route-objects/path-route-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1b457c6c30bb26bde6c4faa632f66d6b65fa9c2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_list
+class path_srlgs_lists(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-srlgs-lists. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path SRLG properties container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_list',)
+
+ _yang_name = 'path-srlgs-lists'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-srlgs-lists']
+
+ def _get_path_srlgs_list(self):
+ """
+ Getter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list (list)
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ return self.__path_srlgs_list
+
+ def _set_path_srlgs_list(self, v, load=False):
+ """
+ Setter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_list() directly.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_list must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_list(self):
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_list = __builtin__.property(_get_path_srlgs_list)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_list', path_srlgs_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..977077b1f8045674eca865b10934c0bb5431a5e1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_list(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-srlgs-lists/path-srlgs-list. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__values',)
+
+ _yang_name = 'path-srlgs-list'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-srlgs-lists', 'path-srlgs-list']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_values(self):
+ """
+ Getter method for values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/values (srlg)
+
+ YANG Description: List of SRLG values.
+ """
+ return self.__values
+
+ def _set_values(self, v, load=False):
+ """
+ Setter method for values, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/values (srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_values() directly.
+
+ YANG Description: List of SRLG values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """values must be of a type compatible with srlg""",
+ 'defined-type': "ietf-te-topology:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)""",
+ })
+
+ self.__values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_values(self):
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ values = __builtin__.property(_get_values)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('values', values), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..219ef7d2740f50432e47cdd50e0c5a53aaada3fe
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_name
+class path_srlgs_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-srlgs-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_name',)
+
+ _yang_name = 'path-srlgs-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-srlgs-names']
+
+ def _get_path_srlgs_name(self):
+ """
+ Getter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name (list)
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ return self.__path_srlgs_name
+
+ def _set_path_srlgs_name(self, v, load=False):
+ """
+ Setter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_name() directly.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_name(self):
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_name = __builtin__.property(_get_path_srlgs_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_name', path_srlgs_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..3f83850b901e1bb7f6ada7ff0652fb47cf930794
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/path-properties/path-srlgs-names/path-srlgs-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__names',)
+
+ _yang_name = 'path-srlgs-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'path-properties', 'path-srlgs-names', 'path-srlgs-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_names(self):
+ """
+ Getter method for names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/names (string)
+
+ YANG Description: List of named SRLGs.
+ """
+ return self.__names
+
+ def _set_names(self, v, load=False):
+ """
+ Setter method for names, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/names (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_names() directly.
+
+ YANG Description: List of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """names must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_names(self):
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ names = __builtin__.property(_get_names)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('names', names), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c61ee40638fd59c1c8254666641420e56be09a8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/__init__.py
@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import primary_path
+from . import backup_path
+from . import tunnel_termination_points
+from . import tunnels
+class underlay(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__enabled','__primary_path','__backup_path','__protection_type','__tunnel_termination_points','__tunnels',)
+
+ _yang_name = 'underlay'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay']
+
+ def _get_enabled(self):
+ """
+ Getter method for enabled, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/enabled (boolean)
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ return self.__enabled
+
+ def _set_enabled(self, v, load=False):
+ """
+ Setter method for enabled, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/enabled (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_enabled is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_enabled() directly.
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """enabled must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)""",
+ })
+
+ self.__enabled = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_enabled(self):
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+
+ def _get_primary_path(self):
+ """
+ Getter method for primary_path, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path (container)
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ return self.__primary_path
+
+ def _set_primary_path(self, v, load=False):
+ """
+ Setter method for primary_path, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_primary_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_primary_path() directly.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """primary_path must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__primary_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_primary_path(self):
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_backup_path(self):
+ """
+ Getter method for backup_path, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path (list)
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ return self.__backup_path
+
+ def _set_backup_path(self, v, load=False):
+ """
+ Setter method for backup_path, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_backup_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_backup_path() directly.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """backup_path must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__backup_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_backup_path(self):
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_protection_type(self):
+ """
+ Getter method for protection_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/protection_type (identityref)
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ return self.__protection_type
+
+ def _set_protection_type(self, v, load=False):
+ """
+ Setter method for protection_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/protection_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_protection_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_protection_type() directly.
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """protection_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__protection_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_protection_type(self):
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_tunnel_termination_points(self):
+ """
+ Getter method for tunnel_termination_points, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points (container)
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ return self.__tunnel_termination_points
+
+ def _set_tunnel_termination_points(self, v, load=False):
+ """
+ Setter method for tunnel_termination_points, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_termination_points is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_termination_points() directly.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_termination_points must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__tunnel_termination_points = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_termination_points(self):
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_tunnels(self):
+ """
+ Getter method for tunnels, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels (container)
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ return self.__tunnels
+
+ def _set_tunnels(self, v, load=False):
+ """
+ Setter method for tunnels, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnels is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnels() directly.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnels must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__tunnels = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnels(self):
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ enabled = __builtin__.property(_get_enabled)
+ primary_path = __builtin__.property(_get_primary_path)
+ backup_path = __builtin__.property(_get_backup_path)
+ protection_type = __builtin__.property(_get_protection_type)
+ tunnel_termination_points = __builtin__.property(_get_tunnel_termination_points)
+ tunnels = __builtin__.property(_get_tunnels)
+
+
+ _pyangbind_elements = OrderedDict([('enabled', enabled), ('primary_path', primary_path), ('backup_path', backup_path), ('protection_type', protection_type), ('tunnel_termination_points', tunnel_termination_points), ('tunnels', tunnels), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..92cc327172f3b1fff0e55b235e17bb9467e8d365
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/__init__.py
@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class backup_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/backup-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__network_ref','__path_element',)
+
+ _yang_name = 'backup-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'backup-path']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/index (uint32)
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element (list)
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ network_ref = __builtin__.property(_get_network_ref)
+ path_element = __builtin__.property(_get_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('index', index), ('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..782347073fd2268022355fceb1a528d9b27cd338
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/__init__.py
@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/backup-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ path_element_id = __builtin__.property(_get_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..75444961d2181499b1641c904b83653ee41e3f66
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/backup-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..77ca590bd1d952e1bb07d94ea8fc90b05820a919
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/backup-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ecefaca5fee07186c0d0e4bd6d8db385434194eb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/backup-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9e7d7a3d8ddfa7c1667c07438782a3485d87368
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/backup-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1433a162123e59c7f146f26b69731aa9b12ffe9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/backup-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..919cb958e08e703c306b0b3c5f63bf665efb40b6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/backup-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4268b048907964b9dac84106f985afad78ad95fc
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/backup-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f8297c2428b23508a5b81f759e727afb707535a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class primary_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/primary-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref','__path_element',)
+
+ _yang_name = 'primary-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'primary-path']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element (list)
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ network_ref = __builtin__.property(_get_network_ref)
+ path_element = __builtin__.property(_get_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c5b869f6aab42d30032b0d62c28653cfd1ceab7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/__init__.py
@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/primary-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ path_element_id = __builtin__.property(_get_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f66d7136eb30f450c4e858c6105cda2616a650b8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/primary-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5913384044adca0adc530c78228b13ef40ee3520
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/primary-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5702d315008463d772546a497f5499a610f291e8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/primary-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d8a5775c84e518b9848dcf49bd6f5767e34134f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/primary-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef124eada429f941ecb01207e1f66cb3cca0bdb1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/primary-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..15377f86d5771b06091695253a7beae8cc48f982
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/primary-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b950c235885e4c2afd13af722f71f644f565c472
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/primary-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6a6987ff720aa02066efd5ad34ce63d2f50c600
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel_termination_points(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/tunnel-termination-points. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__source','__destination',)
+
+ _yang_name = 'tunnel-termination-points'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'tunnel-termination-points']
+
+ def _get_source(self):
+ """
+ Getter method for source, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points/source (binary)
+
+ YANG Description: Source TTP identifier.
+ """
+ return self.__source
+
+ def _set_source(self, v, load=False):
+ """
+ Setter method for source, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points/source (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_source() directly.
+
+ YANG Description: Source TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """source must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)""",
+ })
+
+ self.__source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_source(self):
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+
+
+ def _get_destination(self):
+ """
+ Getter method for destination, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points/destination (binary)
+
+ YANG Description: Destination TTP identifier.
+ """
+ return self.__destination
+
+ def _set_destination(self, v, load=False):
+ """
+ Setter method for destination, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points/destination (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_destination is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_destination() directly.
+
+ YANG Description: Destination TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """destination must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)""",
+ })
+
+ self.__destination = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_destination(self):
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=False)
+
+ source = __builtin__.property(_get_source)
+ destination = __builtin__.property(_get_destination)
+
+
+ _pyangbind_elements = OrderedDict([('source', source), ('destination', destination), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1d6cf9df47fb52c6b856d53f9de35da976c8754
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/__init__.py
@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tunnel
+class tunnels(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/tunnels. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__sharing','__tunnel',)
+
+ _yang_name = 'tunnels'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'tunnels']
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+
+ def _get_tunnel(self):
+ """
+ Getter method for tunnel, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel (list)
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ return self.__tunnel
+
+ def _set_tunnel(self, v, load=False):
+ """
+ Setter method for tunnel, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel() directly.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__tunnel = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel(self):
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ sharing = __builtin__.property(_get_sharing)
+ tunnel = __builtin__.property(_get_tunnel)
+
+
+ _pyangbind_elements = OrderedDict([('sharing', sharing), ('tunnel', tunnel), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f8593123c741f78bb9c17df2ff37cbdc7671475
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel/__init__.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/connectivity-matrices/underlay/tunnels/tunnel. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tunnel_name','__sharing',)
+
+ _yang_name = 'tunnel'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'connectivity-matrices', 'underlay', 'tunnels', 'tunnel']
+
+ def _get_tunnel_name(self):
+ """
+ Getter method for tunnel_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel/tunnel_name (string)
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ return self.__tunnel_name
+
+ def _set_tunnel_name(self, v, load=False):
+ """
+ Setter method for tunnel_name, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel/tunnel_name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_name() directly.
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__tunnel_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_name(self):
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=False)
+
+ tunnel_name = __builtin__.property(_get_tunnel_name)
+ sharing = __builtin__.property(_get_sharing)
+
+
+ _pyangbind_elements = OrderedDict([('tunnel_name', tunnel_name), ('sharing', sharing), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/information_source_state/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/information_source_state/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ee93c90fde18dc4423f1d361606db1723c677c6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/information_source_state/__init__.py
@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import topology
+class information_source_state(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/information-source-state. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__credibility_preference','__logical_network_element','__network_instance','__topology',)
+
+ _yang_name = 'information-source-state'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__credibility_preference = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+ self.__logical_network_element = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__network_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__topology = YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'information-source-state']
+
+ def _get_credibility_preference(self):
+ """
+ Getter method for credibility_preference, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/credibility_preference (uint16)
+
+ YANG Description: The preference value for calculating the Traffic
+Engineering database credibility value used for
+tie-break selection between different information-source
+values. A higher value is preferable.
+ """
+ return self.__credibility_preference
+
+ def _set_credibility_preference(self, v, load=False):
+ """
+ Setter method for credibility_preference, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/credibility_preference (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_credibility_preference is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_credibility_preference() directly.
+
+ YANG Description: The preference value for calculating the Traffic
+Engineering database credibility value used for
+tie-break selection between different information-source
+values. A higher value is preferable.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """credibility_preference must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__credibility_preference = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_credibility_preference(self):
+ self.__credibility_preference = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+
+
+ def _get_logical_network_element(self):
+ """
+ Getter method for logical_network_element, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/logical_network_element (string)
+
+ YANG Description: When applicable, this is the name of a logical network
+element from which the information is learned.
+ """
+ return self.__logical_network_element
+
+ def _set_logical_network_element(self, v, load=False):
+ """
+ Setter method for logical_network_element, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/logical_network_element (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_logical_network_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_logical_network_element() directly.
+
+ YANG Description: When applicable, this is the name of a logical network
+element from which the information is learned.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """logical_network_element must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__logical_network_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_logical_network_element(self):
+ self.__logical_network_element = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_network_instance(self):
+ """
+ Getter method for network_instance, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/network_instance (string)
+
+ YANG Description: When applicable, this is the name of a network instance
+from which the information is learned.
+ """
+ return self.__network_instance
+
+ def _set_network_instance(self, v, load=False):
+ """
+ Setter method for network_instance, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/network_instance (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_instance is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_instance() directly.
+
+ YANG Description: When applicable, this is the name of a network instance
+from which the information is learned.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_instance must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__network_instance = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_instance(self):
+ self.__network_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_topology(self):
+ """
+ Getter method for topology, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/topology (container)
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ return self.__topology
+
+ def _set_topology(self, v, load=False):
+ """
+ Setter method for topology, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/topology (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_topology is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_topology() directly.
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """topology must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__topology = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_topology(self):
+ self.__topology = YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ credibility_preference = __builtin__.property(_get_credibility_preference)
+ logical_network_element = __builtin__.property(_get_logical_network_element)
+ network_instance = __builtin__.property(_get_network_instance)
+ topology = __builtin__.property(_get_topology)
+
+
+ _pyangbind_elements = OrderedDict([('credibility_preference', credibility_preference), ('logical_network_element', logical_network_element), ('network_instance', network_instance), ('topology', topology), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/information_source_state/topology/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/information_source_state/topology/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fc5e047ba0e0fb15046e73a564e3b8ddafe61b7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/information_source_state/topology/__init__.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/information-source-state/topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_ref','__network_ref',)
+
+ _yang_name = 'topology'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'information-source-state', 'topology']
+
+ def _get_node_ref(self):
+ """
+ Getter method for node_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/topology/node_ref (leafref)
+
+ YANG Description: Used to reference a node.
+Nodes are identified relative to the network that
+contains them.
+ """
+ return self.__node_ref
+
+ def _set_node_ref(self, v, load=False):
+ """
+ Setter method for node_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/topology/node_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_ref() directly.
+
+ YANG Description: Used to reference a node.
+Nodes are identified relative to the network that
+contains them.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__node_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_ref(self):
+ self.__node_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/topology/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/information_source_state/topology/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+ node_ref = __builtin__.property(_get_node_ref)
+ network_ref = __builtin__.property(_get_network_ref)
+
+
+ _pyangbind_elements = OrderedDict([('node_ref', node_ref), ('network_ref', network_ref), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/underlay_topology/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/underlay_topology/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0d77ce6f2e10688d323486da70dcf638c78a689
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_entry/underlay_topology/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class underlay_topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-entry/underlay-topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: When an abstract node encapsulates a topology, the
+attributes in this container point to said topology.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref',)
+
+ _yang_name = 'underlay-topology'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-entry', 'underlay-topology']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/underlay_topology/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_entry/underlay_topology/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+ network_ref = __builtin__.property(_get_network_ref)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_state/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_state/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7767ff2b6caded6441d09a3195e7ded1c7ef40fa
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_state/__init__.py
@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import topology
+class information_source_state(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-state. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains state attributes related to the information
+source.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__credibility_preference','__logical_network_element','__network_instance','__topology',)
+
+ _yang_name = 'information-source-state'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__credibility_preference = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+ self.__logical_network_element = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__network_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ self.__topology = YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-state']
+
+ def _get_credibility_preference(self):
+ """
+ Getter method for credibility_preference, mapped from YANG variable /networks/network/node/te/information_source_state/credibility_preference (uint16)
+
+ YANG Description: The preference value for calculating the Traffic
+Engineering database credibility value used for
+tie-break selection between different information-source
+values. A higher value is preferable.
+ """
+ return self.__credibility_preference
+
+ def _set_credibility_preference(self, v, load=False):
+ """
+ Setter method for credibility_preference, mapped from YANG variable /networks/network/node/te/information_source_state/credibility_preference (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_credibility_preference is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_credibility_preference() directly.
+
+ YANG Description: The preference value for calculating the Traffic
+Engineering database credibility value used for
+tie-break selection between different information-source
+values. A higher value is preferable.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """credibility_preference must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)""",
+ })
+
+ self.__credibility_preference = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_credibility_preference(self):
+ self.__credibility_preference = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="credibility-preference", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=False)
+
+
+ def _get_logical_network_element(self):
+ """
+ Getter method for logical_network_element, mapped from YANG variable /networks/network/node/te/information_source_state/logical_network_element (string)
+
+ YANG Description: When applicable, this is the name of a logical network
+element from which the information is learned.
+ """
+ return self.__logical_network_element
+
+ def _set_logical_network_element(self, v, load=False):
+ """
+ Setter method for logical_network_element, mapped from YANG variable /networks/network/node/te/information_source_state/logical_network_element (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_logical_network_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_logical_network_element() directly.
+
+ YANG Description: When applicable, this is the name of a logical network
+element from which the information is learned.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """logical_network_element must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__logical_network_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_logical_network_element(self):
+ self.__logical_network_element = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="logical-network-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_network_instance(self):
+ """
+ Getter method for network_instance, mapped from YANG variable /networks/network/node/te/information_source_state/network_instance (string)
+
+ YANG Description: When applicable, this is the name of a network instance
+from which the information is learned.
+ """
+ return self.__network_instance
+
+ def _set_network_instance(self, v, load=False):
+ """
+ Setter method for network_instance, mapped from YANG variable /networks/network/node/te/information_source_state/network_instance (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_instance is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_instance() directly.
+
+ YANG Description: When applicable, this is the name of a network instance
+from which the information is learned.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_instance must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__network_instance = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_instance(self):
+ self.__network_instance = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-instance", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+
+ def _get_topology(self):
+ """
+ Getter method for topology, mapped from YANG variable /networks/network/node/te/information_source_state/topology (container)
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ return self.__topology
+
+ def _set_topology(self, v, load=False):
+ """
+ Setter method for topology, mapped from YANG variable /networks/network/node/te/information_source_state/topology (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_topology is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_topology() directly.
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """topology must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__topology = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_topology(self):
+ self.__topology = YANGDynClass(base=topology.topology, is_container='container', yang_name="topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ credibility_preference = __builtin__.property(_get_credibility_preference)
+ logical_network_element = __builtin__.property(_get_logical_network_element)
+ network_instance = __builtin__.property(_get_network_instance)
+ topology = __builtin__.property(_get_topology)
+
+
+ _pyangbind_elements = OrderedDict([('credibility_preference', credibility_preference), ('logical_network_element', logical_network_element), ('network_instance', network_instance), ('topology', topology), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_state/topology/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_state/topology/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6562d900333f751e9b819293eaf11322757eeaf0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/information_source_state/topology/__init__.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/information-source-state/topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: When the information is processed by the system,
+the attributes in this container indicate which topology
+is used to generate the result information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_ref','__network_ref',)
+
+ _yang_name = 'topology'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'information-source-state', 'topology']
+
+ def _get_node_ref(self):
+ """
+ Getter method for node_ref, mapped from YANG variable /networks/network/node/te/information_source_state/topology/node_ref (leafref)
+
+ YANG Description: Used to reference a node.
+Nodes are identified relative to the network that
+contains them.
+ """
+ return self.__node_ref
+
+ def _set_node_ref(self, v, load=False):
+ """
+ Setter method for node_ref, mapped from YANG variable /networks/network/node/te/information_source_state/topology/node_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_ref() directly.
+
+ YANG Description: Used to reference a node.
+Nodes are identified relative to the network that
+contains them.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__node_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_ref(self):
+ self.__node_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="node-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_state/topology/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/information_source_state/topology/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=False)
+
+ node_ref = __builtin__.property(_get_node_ref)
+ network_ref = __builtin__.property(_get_network_ref)
+
+
+ _pyangbind_elements = OrderedDict([('node_ref', node_ref), ('network_ref', network_ref), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/statistics/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/statistics/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6741fb0fd254c5a6f683304025aed5da58832b0f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/statistics/__init__.py
@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import node
+from . import connectivity_matrix_entry
+class statistics(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/statistics. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Statistics data.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__discontinuity_time','__node','__connectivity_matrix_entry',)
+
+ _yang_name = 'statistics'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__discontinuity_time = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[\\+\\-]\\d{2}:\\d{2})'}), is_leaf=True, yang_name="discontinuity-time", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:date-and-time', is_config=False)
+ self.__node = YANGDynClass(base=node.node, is_container='container', yang_name="node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__connectivity_matrix_entry = YANGDynClass(base=connectivity_matrix_entry.connectivity_matrix_entry, is_container='container', yang_name="connectivity-matrix-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'statistics']
+
+ def _get_discontinuity_time(self):
+ """
+ Getter method for discontinuity_time, mapped from YANG variable /networks/network/node/te/statistics/discontinuity_time (yang:date-and-time)
+
+ YANG Description: The time of the most recent occasion at which any one or
+more of this interface's counters suffered a
+discontinuity. If no such discontinuities have occurred
+since the last re-initialization of the local management
+subsystem, then this node contains the time the local
+management subsystem re-initialized itself.
+ """
+ return self.__discontinuity_time
+
+ def _set_discontinuity_time(self, v, load=False):
+ """
+ Setter method for discontinuity_time, mapped from YANG variable /networks/network/node/te/statistics/discontinuity_time (yang:date-and-time)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_discontinuity_time is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_discontinuity_time() directly.
+
+ YANG Description: The time of the most recent occasion at which any one or
+more of this interface's counters suffered a
+discontinuity. If no such discontinuities have occurred
+since the last re-initialization of the local management
+subsystem, then this node contains the time the local
+management subsystem re-initialized itself.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[\\+\\-]\\d{2}:\\d{2})'}), is_leaf=True, yang_name="discontinuity-time", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:date-and-time', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """discontinuity_time must be of a type compatible with yang:date-and-time""",
+ 'defined-type': "yang:date-and-time",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[\\+\\-]\\d{2}:\\d{2})'}), is_leaf=True, yang_name="discontinuity-time", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:date-and-time', is_config=False)""",
+ })
+
+ self.__discontinuity_time = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_discontinuity_time(self):
+ self.__discontinuity_time = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[\\+\\-]\\d{2}:\\d{2})'}), is_leaf=True, yang_name="discontinuity-time", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:date-and-time', is_config=False)
+
+
+ def _get_node(self):
+ """
+ Getter method for node, mapped from YANG variable /networks/network/node/te/statistics/node (container)
+
+ YANG Description: Contains statistics attributes at the TE node level.
+ """
+ return self.__node
+
+ def _set_node(self, v, load=False):
+ """
+ Setter method for node, mapped from YANG variable /networks/network/node/te/statistics/node (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node() directly.
+
+ YANG Description: Contains statistics attributes at the TE node level.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=node.node, is_container='container', yang_name="node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=node.node, is_container='container', yang_name="node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__node = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node(self):
+ self.__node = YANGDynClass(base=node.node, is_container='container', yang_name="node", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_connectivity_matrix_entry(self):
+ """
+ Getter method for connectivity_matrix_entry, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry (container)
+
+ YANG Description: Contains statistics attributes at the level of a
+connectivity matrix entry.
+ """
+ return self.__connectivity_matrix_entry
+
+ def _set_connectivity_matrix_entry(self, v, load=False):
+ """
+ Setter method for connectivity_matrix_entry, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_connectivity_matrix_entry is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_connectivity_matrix_entry() directly.
+
+ YANG Description: Contains statistics attributes at the level of a
+connectivity matrix entry.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=connectivity_matrix_entry.connectivity_matrix_entry, is_container='container', yang_name="connectivity-matrix-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """connectivity_matrix_entry must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=connectivity_matrix_entry.connectivity_matrix_entry, is_container='container', yang_name="connectivity-matrix-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__connectivity_matrix_entry = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_connectivity_matrix_entry(self):
+ self.__connectivity_matrix_entry = YANGDynClass(base=connectivity_matrix_entry.connectivity_matrix_entry, is_container='container', yang_name="connectivity-matrix-entry", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ discontinuity_time = __builtin__.property(_get_discontinuity_time)
+ node = __builtin__.property(_get_node)
+ connectivity_matrix_entry = __builtin__.property(_get_connectivity_matrix_entry)
+
+
+ _pyangbind_elements = OrderedDict([('discontinuity_time', discontinuity_time), ('node', node), ('connectivity_matrix_entry', connectivity_matrix_entry), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/statistics/connectivity_matrix_entry/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/statistics/connectivity_matrix_entry/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c96f28c4c8867f027fead21227e752e58f4a950
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/statistics/connectivity_matrix_entry/__init__.py
@@ -0,0 +1,282 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class connectivity_matrix_entry(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/statistics/connectivity-matrix-entry. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains statistics attributes at the level of a
+connectivity matrix entry.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__creates','__deletes','__disables','__enables','__modifies',)
+
+ _yang_name = 'connectivity-matrix-entry'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__creates = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="creates", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__deletes = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="deletes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__disables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__enables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__modifies = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'statistics', 'connectivity-matrix-entry']
+
+ def _get_creates(self):
+ """
+ Getter method for creates, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry/creates (yang:counter32)
+
+ YANG Description: Number of times that a connectivity matrix entry was
+created.
+ """
+ return self.__creates
+
+ def _set_creates(self, v, load=False):
+ """
+ Setter method for creates, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry/creates (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_creates is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_creates() directly.
+
+ YANG Description: Number of times that a connectivity matrix entry was
+created.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="creates", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """creates must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="creates", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__creates = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_creates(self):
+ self.__creates = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="creates", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_deletes(self):
+ """
+ Getter method for deletes, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry/deletes (yang:counter32)
+
+ YANG Description: Number of times that a connectivity matrix entry was
+deleted.
+ """
+ return self.__deletes
+
+ def _set_deletes(self, v, load=False):
+ """
+ Setter method for deletes, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry/deletes (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_deletes is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_deletes() directly.
+
+ YANG Description: Number of times that a connectivity matrix entry was
+deleted.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="deletes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """deletes must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="deletes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__deletes = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_deletes(self):
+ self.__deletes = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="deletes", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_disables(self):
+ """
+ Getter method for disables, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry/disables (yang:counter32)
+
+ YANG Description: Number of times that a connectivity matrix entry was
+disabled.
+ """
+ return self.__disables
+
+ def _set_disables(self, v, load=False):
+ """
+ Setter method for disables, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry/disables (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_disables is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_disables() directly.
+
+ YANG Description: Number of times that a connectivity matrix entry was
+disabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """disables must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__disables = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_disables(self):
+ self.__disables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_enables(self):
+ """
+ Getter method for enables, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry/enables (yang:counter32)
+
+ YANG Description: Number of times that a connectivity matrix entry was
+enabled.
+ """
+ return self.__enables
+
+ def _set_enables(self, v, load=False):
+ """
+ Setter method for enables, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry/enables (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_enables is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_enables() directly.
+
+ YANG Description: Number of times that a connectivity matrix entry was
+enabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """enables must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__enables = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_enables(self):
+ self.__enables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_modifies(self):
+ """
+ Getter method for modifies, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry/modifies (yang:counter32)
+
+ YANG Description: Number of times that a connectivity matrix entry was
+modified.
+ """
+ return self.__modifies
+
+ def _set_modifies(self, v, load=False):
+ """
+ Setter method for modifies, mapped from YANG variable /networks/network/node/te/statistics/connectivity_matrix_entry/modifies (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_modifies is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_modifies() directly.
+
+ YANG Description: Number of times that a connectivity matrix entry was
+modified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """modifies must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__modifies = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_modifies(self):
+ self.__modifies = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+ creates = __builtin__.property(_get_creates)
+ deletes = __builtin__.property(_get_deletes)
+ disables = __builtin__.property(_get_disables)
+ enables = __builtin__.property(_get_enables)
+ modifies = __builtin__.property(_get_modifies)
+
+
+ _pyangbind_elements = OrderedDict([('creates', creates), ('deletes', deletes), ('disables', disables), ('enables', enables), ('modifies', modifies), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/statistics/node/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/statistics/node/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d1e11b5e10ceff699b7ddaf2a947af002a18db6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/statistics/node/__init__.py
@@ -0,0 +1,273 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class node(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/statistics/node. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains statistics attributes at the TE node level.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__disables','__enables','__maintenance_sets','__maintenance_clears','__modifies',)
+
+ _yang_name = 'node'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__disables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__enables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__maintenance_sets = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-sets", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__maintenance_clears = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ self.__modifies = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'statistics', 'node']
+
+ def _get_disables(self):
+ """
+ Getter method for disables, mapped from YANG variable /networks/network/node/te/statistics/node/disables (yang:counter32)
+
+ YANG Description: Number of times that a node was disabled.
+ """
+ return self.__disables
+
+ def _set_disables(self, v, load=False):
+ """
+ Setter method for disables, mapped from YANG variable /networks/network/node/te/statistics/node/disables (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_disables is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_disables() directly.
+
+ YANG Description: Number of times that a node was disabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """disables must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__disables = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_disables(self):
+ self.__disables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="disables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_enables(self):
+ """
+ Getter method for enables, mapped from YANG variable /networks/network/node/te/statistics/node/enables (yang:counter32)
+
+ YANG Description: Number of times that a node was enabled.
+ """
+ return self.__enables
+
+ def _set_enables(self, v, load=False):
+ """
+ Setter method for enables, mapped from YANG variable /networks/network/node/te/statistics/node/enables (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_enables is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_enables() directly.
+
+ YANG Description: Number of times that a node was enabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """enables must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__enables = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_enables(self):
+ self.__enables = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="enables", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_maintenance_sets(self):
+ """
+ Getter method for maintenance_sets, mapped from YANG variable /networks/network/node/te/statistics/node/maintenance_sets (yang:counter32)
+
+ YANG Description: Number of times that a node was put in maintenance.
+ """
+ return self.__maintenance_sets
+
+ def _set_maintenance_sets(self, v, load=False):
+ """
+ Setter method for maintenance_sets, mapped from YANG variable /networks/network/node/te/statistics/node/maintenance_sets (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_maintenance_sets is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_maintenance_sets() directly.
+
+ YANG Description: Number of times that a node was put in maintenance.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-sets", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """maintenance_sets must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-sets", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__maintenance_sets = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_maintenance_sets(self):
+ self.__maintenance_sets = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-sets", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_maintenance_clears(self):
+ """
+ Getter method for maintenance_clears, mapped from YANG variable /networks/network/node/te/statistics/node/maintenance_clears (yang:counter32)
+
+ YANG Description: Number of times that a node was taken out of
+maintenance.
+ """
+ return self.__maintenance_clears
+
+ def _set_maintenance_clears(self, v, load=False):
+ """
+ Setter method for maintenance_clears, mapped from YANG variable /networks/network/node/te/statistics/node/maintenance_clears (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_maintenance_clears is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_maintenance_clears() directly.
+
+ YANG Description: Number of times that a node was taken out of
+maintenance.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """maintenance_clears must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__maintenance_clears = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_maintenance_clears(self):
+ self.__maintenance_clears = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="maintenance-clears", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+
+ def _get_modifies(self):
+ """
+ Getter method for modifies, mapped from YANG variable /networks/network/node/te/statistics/node/modifies (yang:counter32)
+
+ YANG Description: Number of times that a node was modified.
+ """
+ return self.__modifies
+
+ def _set_modifies(self, v, load=False):
+ """
+ Setter method for modifies, mapped from YANG variable /networks/network/node/te/statistics/node/modifies (yang:counter32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_modifies is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_modifies() directly.
+
+ YANG Description: Number of times that a node was modified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """modifies must be of a type compatible with yang:counter32""",
+ 'defined-type': "yang:counter32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)""",
+ })
+
+ self.__modifies = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_modifies(self):
+ self.__modifies = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="modifies", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:counter32', is_config=False)
+
+ disables = __builtin__.property(_get_disables)
+ enables = __builtin__.property(_get_enables)
+ maintenance_sets = __builtin__.property(_get_maintenance_sets)
+ maintenance_clears = __builtin__.property(_get_maintenance_clears)
+ modifies = __builtin__.property(_get_modifies)
+
+
+ _pyangbind_elements = OrderedDict([('disables', disables), ('enables', enables), ('maintenance_sets', maintenance_sets), ('maintenance_clears', maintenance_clears), ('modifies', modifies), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..08e7f93bea49d7c90b4edd56733e6f13dfdbc845
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/__init__.py
@@ -0,0 +1,357 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import connectivity_matrices
+from . import underlay_topology
+class te_node_attributes(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains node attributes in a TE topology.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__admin_status','__connectivity_matrices','__domain_id','__is_abstract','__name','__signaling_address','__underlay_topology',)
+
+ _yang_name = 'te-node-attributes'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__admin_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)
+ self.__connectivity_matrices = YANGDynClass(base=connectivity_matrices.connectivity_matrices, is_container='container', yang_name="connectivity-matrices", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__domain_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="domain-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__is_abstract = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=True)
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ self.__signaling_address = YANGDynClass(unique=True, base=TypedListType(allowed_type=[RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),]), is_leaf=False, yang_name="signaling-address", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:ip-address', is_config=True)
+ self.__underlay_topology = YANGDynClass(base=underlay_topology.underlay_topology, is_container='container', yang_name="underlay-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes']
+
+ def _get_admin_status(self):
+ """
+ Getter method for admin_status, mapped from YANG variable /networks/network/node/te/te_node_attributes/admin_status (te-types:te-admin-status)
+
+ YANG Description: The administrative state of the link.
+ """
+ return self.__admin_status
+
+ def _set_admin_status(self, v, load=False):
+ """
+ Setter method for admin_status, mapped from YANG variable /networks/network/node/te/te_node_attributes/admin_status (te-types:te-admin-status)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_admin_status is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_admin_status() directly.
+
+ YANG Description: The administrative state of the link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """admin_status must be of a type compatible with te-types:te-admin-status""",
+ 'defined-type': "te-types:te-admin-status",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)""",
+ })
+
+ self.__admin_status = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_admin_status(self):
+ self.__admin_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)
+
+
+ def _get_connectivity_matrices(self):
+ """
+ Getter method for connectivity_matrices, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices (container)
+
+ YANG Description: Contains a connectivity matrix on a TE node.
+ """
+ return self.__connectivity_matrices
+
+ def _set_connectivity_matrices(self, v, load=False):
+ """
+ Setter method for connectivity_matrices, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_connectivity_matrices is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_connectivity_matrices() directly.
+
+ YANG Description: Contains a connectivity matrix on a TE node.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=connectivity_matrices.connectivity_matrices, is_container='container', yang_name="connectivity-matrices", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """connectivity_matrices must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=connectivity_matrices.connectivity_matrices, is_container='container', yang_name="connectivity-matrices", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__connectivity_matrices = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_connectivity_matrices(self):
+ self.__connectivity_matrices = YANGDynClass(base=connectivity_matrices.connectivity_matrices, is_container='container', yang_name="connectivity-matrices", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_domain_id(self):
+ """
+ Getter method for domain_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/domain_id (uint32)
+
+ YANG Description: Identifies the domain to which this node belongs.
+This attribute is used to support inter-domain links.
+ """
+ return self.__domain_id
+
+ def _set_domain_id(self, v, load=False):
+ """
+ Setter method for domain_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/domain_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_domain_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_domain_id() directly.
+
+ YANG Description: Identifies the domain to which this node belongs.
+This attribute is used to support inter-domain links.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="domain-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """domain_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="domain-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__domain_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_domain_id(self):
+ self.__domain_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="domain-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_is_abstract(self):
+ """
+ Getter method for is_abstract, mapped from YANG variable /networks/network/node/te/te_node_attributes/is_abstract (empty)
+
+ YANG Description: Present if the node is abstract; not present if the node
+is actual.
+ """
+ return self.__is_abstract
+
+ def _set_is_abstract(self, v, load=False):
+ """
+ Setter method for is_abstract, mapped from YANG variable /networks/network/node/te/te_node_attributes/is_abstract (empty)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_abstract is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_abstract() directly.
+
+ YANG Description: Present if the node is abstract; not present if the node
+is actual.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_abstract must be of a type compatible with empty""",
+ 'defined-type': "empty",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=True)""",
+ })
+
+ self.__is_abstract = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_abstract(self):
+ self.__is_abstract = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-abstract", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='empty', is_config=True)
+
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/te_node_attributes/name (string)
+
+ YANG Description: Node name.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/te_node_attributes/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Node name.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+
+ def _get_signaling_address(self):
+ """
+ Getter method for signaling_address, mapped from YANG variable /networks/network/node/te/te_node_attributes/signaling_address (inet:ip-address)
+
+ YANG Description: The node's signaling address.
+ """
+ return self.__signaling_address
+
+ def _set_signaling_address(self, v, load=False):
+ """
+ Setter method for signaling_address, mapped from YANG variable /networks/network/node/te/te_node_attributes/signaling_address (inet:ip-address)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_signaling_address is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_signaling_address() directly.
+
+ YANG Description: The node's signaling address.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=[RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),]), is_leaf=False, yang_name="signaling-address", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:ip-address', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """signaling_address must be of a type compatible with inet:ip-address""",
+ 'defined-type': "inet:ip-address",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=[RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),]), is_leaf=False, yang_name="signaling-address", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:ip-address', is_config=True)""",
+ })
+
+ self.__signaling_address = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_signaling_address(self):
+ self.__signaling_address = YANGDynClass(unique=True, base=TypedListType(allowed_type=[RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),]), is_leaf=False, yang_name="signaling-address", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:ip-address', is_config=True)
+
+
+ def _get_underlay_topology(self):
+ """
+ Getter method for underlay_topology, mapped from YANG variable /networks/network/node/te/te_node_attributes/underlay_topology (container)
+
+ YANG Description: When an abstract node encapsulates a topology, the
+attributes in this container point to said topology.
+ """
+ return self.__underlay_topology
+
+ def _set_underlay_topology(self, v, load=False):
+ """
+ Setter method for underlay_topology, mapped from YANG variable /networks/network/node/te/te_node_attributes/underlay_topology (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_underlay_topology is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_underlay_topology() directly.
+
+ YANG Description: When an abstract node encapsulates a topology, the
+attributes in this container point to said topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=underlay_topology.underlay_topology, is_container='container', yang_name="underlay-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """underlay_topology must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=underlay_topology.underlay_topology, is_container='container', yang_name="underlay-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__underlay_topology = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_underlay_topology(self):
+ self.__underlay_topology = YANGDynClass(base=underlay_topology.underlay_topology, is_container='container', yang_name="underlay-topology", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ admin_status = __builtin__.property(_get_admin_status, _set_admin_status)
+ connectivity_matrices = __builtin__.property(_get_connectivity_matrices, _set_connectivity_matrices)
+ domain_id = __builtin__.property(_get_domain_id, _set_domain_id)
+ is_abstract = __builtin__.property(_get_is_abstract, _set_is_abstract)
+ name = __builtin__.property(_get_name, _set_name)
+ signaling_address = __builtin__.property(_get_signaling_address, _set_signaling_address)
+ underlay_topology = __builtin__.property(_get_underlay_topology, _set_underlay_topology)
+
+
+ _pyangbind_elements = OrderedDict([('admin_status', admin_status), ('connectivity_matrices', connectivity_matrices), ('domain_id', domain_id), ('is_abstract', is_abstract), ('name', name), ('signaling_address', signaling_address), ('underlay_topology', underlay_topology), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1a23ffc8361fba2a308618e731f8f2dd3e20f1b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/__init__.py
@@ -0,0 +1,412 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restrictions
+from . import underlay
+from . import path_constraints
+from . import optimizations
+from . import path_properties
+from . import connectivity_matrix
+class connectivity_matrices(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains a connectivity matrix on a TE node.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__number_of_entries','__label_restrictions','__is_allowed','__underlay','__path_constraints','__optimizations','__path_properties','__connectivity_matrix',)
+
+ _yang_name = 'connectivity-matrices'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__number_of_entries = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=True)
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__connectivity_matrix = YANGDynClass(base=YANGListType("id",connectivity_matrix.connectivity_matrix, yang_name="connectivity-matrix", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='id', extensions=None), is_container='list', yang_name="connectivity-matrix", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices']
+
+ def _get_number_of_entries(self):
+ """
+ Getter method for number_of_entries, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/number_of_entries (uint16)
+
+ YANG Description: The number of connectivity matrix entries.
+If this number is specified in the configuration request,
+the number is the requested number of entries, which may
+not all be listed in the list;
+if this number is reported in the state data,
+the number is the current number of operational entries.
+ """
+ return self.__number_of_entries
+
+ def _set_number_of_entries(self, v, load=False):
+ """
+ Setter method for number_of_entries, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/number_of_entries (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number_of_entries is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number_of_entries() directly.
+
+ YANG Description: The number of connectivity matrix entries.
+If this number is specified in the configuration request,
+the number is the requested number of entries, which may
+not all be listed in the list;
+if this number is reported in the state data,
+the number is the current number of operational entries.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number_of_entries must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__number_of_entries = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number_of_entries(self):
+ self.__number_of_entries = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=True)
+
+
+ def _get_label_restrictions(self):
+ """
+ Getter method for label_restrictions, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions (container)
+
+ YANG Description: The label restrictions container.
+ """
+ return self.__label_restrictions
+
+ def _set_label_restrictions(self, v, load=False):
+ """
+ Setter method for label_restrictions, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restrictions is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restrictions() directly.
+
+ YANG Description: The label restrictions container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restrictions must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_restrictions = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restrictions(self):
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_is_allowed(self):
+ """
+ Getter method for is_allowed, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/is_allowed (boolean)
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ return self.__is_allowed
+
+ def _set_is_allowed(self, v, load=False):
+ """
+ Setter method for is_allowed, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/is_allowed (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_allowed is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_allowed() directly.
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_allowed must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__is_allowed = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_allowed(self):
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_underlay(self):
+ """
+ Getter method for underlay, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay (container)
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ return self.__underlay
+
+ def _set_underlay(self, v, load=False):
+ """
+ Setter method for underlay, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_underlay is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_underlay() directly.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """underlay must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__underlay = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_underlay(self):
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_constraints(self):
+ """
+ Getter method for path_constraints, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints (container)
+
+ YANG Description: TE named path constraints container.
+ """
+ return self.__path_constraints
+
+ def _set_path_constraints(self, v, load=False):
+ """
+ Setter method for path_constraints, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_constraints is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_constraints() directly.
+
+ YANG Description: TE named path constraints container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_constraints must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_constraints = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_constraints(self):
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_optimizations(self):
+ """
+ Getter method for optimizations, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__optimizations
+
+ def _set_optimizations(self, v, load=False):
+ """
+ Setter method for optimizations, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimizations is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimizations() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimizations must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__optimizations = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimizations(self):
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_properties(self):
+ """
+ Getter method for path_properties, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties (container)
+
+ YANG Description: The TE path properties.
+ """
+ return self.__path_properties
+
+ def _set_path_properties(self, v, load=False):
+ """
+ Setter method for path_properties, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_properties is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_properties() directly.
+
+ YANG Description: The TE path properties.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_properties must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_properties = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_properties(self):
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_connectivity_matrix(self):
+ """
+ Getter method for connectivity_matrix, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix (list)
+
+ YANG Description: Represents a node's switching limitations, i.e.,
+limitations in the interconnecting network TE links
+across the node.
+ """
+ return self.__connectivity_matrix
+
+ def _set_connectivity_matrix(self, v, load=False):
+ """
+ Setter method for connectivity_matrix, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_connectivity_matrix is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_connectivity_matrix() directly.
+
+ YANG Description: Represents a node's switching limitations, i.e.,
+limitations in the interconnecting network TE links
+across the node.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("id",connectivity_matrix.connectivity_matrix, yang_name="connectivity-matrix", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='id', extensions=None), is_container='list', yang_name="connectivity-matrix", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """connectivity_matrix must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("id",connectivity_matrix.connectivity_matrix, yang_name="connectivity-matrix", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='id', extensions=None), is_container='list', yang_name="connectivity-matrix", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__connectivity_matrix = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_connectivity_matrix(self):
+ self.__connectivity_matrix = YANGDynClass(base=YANGListType("id",connectivity_matrix.connectivity_matrix, yang_name="connectivity-matrix", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='id', extensions=None), is_container='list', yang_name="connectivity-matrix", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ number_of_entries = __builtin__.property(_get_number_of_entries, _set_number_of_entries)
+ label_restrictions = __builtin__.property(_get_label_restrictions, _set_label_restrictions)
+ is_allowed = __builtin__.property(_get_is_allowed, _set_is_allowed)
+ underlay = __builtin__.property(_get_underlay, _set_underlay)
+ path_constraints = __builtin__.property(_get_path_constraints, _set_path_constraints)
+ optimizations = __builtin__.property(_get_optimizations, _set_optimizations)
+ path_properties = __builtin__.property(_get_path_properties)
+ connectivity_matrix = __builtin__.property(_get_connectivity_matrix, _set_connectivity_matrix)
+
+
+ _pyangbind_elements = OrderedDict([('number_of_entries', number_of_entries), ('label_restrictions', label_restrictions), ('is_allowed', is_allowed), ('underlay', underlay), ('path_constraints', path_constraints), ('optimizations', optimizations), ('path_properties', path_properties), ('connectivity_matrix', connectivity_matrix), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..704040fa4ee6069477ddbfb7ad51bdbd33ca4ba5
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/__init__.py
@@ -0,0 +1,405 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import from_
+from . import to
+from . import underlay
+from . import path_constraints
+from . import optimizations
+from . import path_properties
+class connectivity_matrix(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Represents a node's switching limitations, i.e.,
+limitations in the interconnecting network TE links
+across the node.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__id','__from_','__to','__is_allowed','__underlay','__path_constraints','__optimizations','__path_properties',)
+
+ _yang_name = 'connectivity-matrix'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__from_ = YANGDynClass(base=from_.from_, is_container='container', yang_name="from", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__to = YANGDynClass(base=to.to, is_container='container', yang_name="to", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix']
+
+ def _get_id(self):
+ """
+ Getter method for id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/id (uint32)
+
+ YANG Description: Identifies the connectivity matrix entry.
+ """
+ return self.__id
+
+ def _set_id(self, v, load=False):
+ """
+ Setter method for id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_id() directly.
+
+ YANG Description: Identifies the connectivity matrix entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_id(self):
+ self.__id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_from_(self):
+ """
+ Getter method for from_, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from (container)
+
+ YANG Description: Reference to a source LTP.
+ """
+ return self.__from_
+
+ def _set_from_(self, v, load=False):
+ """
+ Setter method for from_, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_from_ is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_from_() directly.
+
+ YANG Description: Reference to a source LTP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=from_.from_, is_container='container', yang_name="from", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """from_ must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=from_.from_, is_container='container', yang_name="from", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__from_ = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_from_(self):
+ self.__from_ = YANGDynClass(base=from_.from_, is_container='container', yang_name="from", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_to(self):
+ """
+ Getter method for to, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to (container)
+
+ YANG Description: Reference to a destination LTP.
+ """
+ return self.__to
+
+ def _set_to(self, v, load=False):
+ """
+ Setter method for to, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_to is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_to() directly.
+
+ YANG Description: Reference to a destination LTP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=to.to, is_container='container', yang_name="to", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """to must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=to.to, is_container='container', yang_name="to", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__to = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_to(self):
+ self.__to = YANGDynClass(base=to.to, is_container='container', yang_name="to", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_is_allowed(self):
+ """
+ Getter method for is_allowed, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/is_allowed (boolean)
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ return self.__is_allowed
+
+ def _set_is_allowed(self, v, load=False):
+ """
+ Setter method for is_allowed, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/is_allowed (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_allowed is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_allowed() directly.
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_allowed must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__is_allowed = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_allowed(self):
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_underlay(self):
+ """
+ Getter method for underlay, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay (container)
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ return self.__underlay
+
+ def _set_underlay(self, v, load=False):
+ """
+ Setter method for underlay, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_underlay is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_underlay() directly.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """underlay must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__underlay = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_underlay(self):
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_constraints(self):
+ """
+ Getter method for path_constraints, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints (container)
+
+ YANG Description: TE named path constraints container.
+ """
+ return self.__path_constraints
+
+ def _set_path_constraints(self, v, load=False):
+ """
+ Setter method for path_constraints, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_constraints is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_constraints() directly.
+
+ YANG Description: TE named path constraints container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_constraints must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_constraints = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_constraints(self):
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_optimizations(self):
+ """
+ Getter method for optimizations, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__optimizations
+
+ def _set_optimizations(self, v, load=False):
+ """
+ Setter method for optimizations, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimizations is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimizations() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimizations must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__optimizations = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimizations(self):
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_properties(self):
+ """
+ Getter method for path_properties, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties (container)
+
+ YANG Description: The TE path properties.
+ """
+ return self.__path_properties
+
+ def _set_path_properties(self, v, load=False):
+ """
+ Setter method for path_properties, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_properties is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_properties() directly.
+
+ YANG Description: The TE path properties.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_properties must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_properties = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_properties(self):
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ id = __builtin__.property(_get_id, _set_id)
+ from_ = __builtin__.property(_get_from_, _set_from_)
+ to = __builtin__.property(_get_to, _set_to)
+ is_allowed = __builtin__.property(_get_is_allowed, _set_is_allowed)
+ underlay = __builtin__.property(_get_underlay, _set_underlay)
+ path_constraints = __builtin__.property(_get_path_constraints, _set_path_constraints)
+ optimizations = __builtin__.property(_get_optimizations, _set_optimizations)
+ path_properties = __builtin__.property(_get_path_properties)
+
+
+ _pyangbind_elements = OrderedDict([('id', id), ('from_', from_), ('to', to), ('is_allowed', is_allowed), ('underlay', underlay), ('path_constraints', path_constraints), ('optimizations', optimizations), ('path_properties', path_properties), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..40157c9047e4ea2039558fa9dfbb4eb1349046b3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/__init__.py
@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restrictions
+class from_(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Reference to a source LTP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tp_ref','__label_restrictions',)
+
+ _yang_name = 'from'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from']
+
+ def _get_tp_ref(self):
+ """
+ Getter method for tp_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/tp_ref (leafref)
+
+ YANG Description: Relative reference to a termination point.
+ """
+ return self.__tp_ref
+
+ def _set_tp_ref(self, v, load=False):
+ """
+ Setter method for tp_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/tp_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tp_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tp_ref() directly.
+
+ YANG Description: Relative reference to a termination point.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tp_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__tp_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tp_ref(self):
+ self.__tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_label_restrictions(self):
+ """
+ Getter method for label_restrictions, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions (container)
+
+ YANG Description: The label restrictions container.
+ """
+ return self.__label_restrictions
+
+ def _set_label_restrictions(self, v, load=False):
+ """
+ Setter method for label_restrictions, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restrictions is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restrictions() directly.
+
+ YANG Description: The label restrictions container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restrictions must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_restrictions = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restrictions(self):
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ tp_ref = __builtin__.property(_get_tp_ref, _set_tp_ref)
+ label_restrictions = __builtin__.property(_get_label_restrictions, _set_label_restrictions)
+
+
+ _pyangbind_elements = OrderedDict([('tp_ref', tp_ref), ('label_restrictions', label_restrictions), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a441f8e0c6c181850335c85898e65d7ab956970
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restriction
+class label_restrictions(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The label restrictions container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__label_restriction',)
+
+ _yang_name = 'label-restrictions'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions']
+
+ def _get_label_restriction(self):
+ """
+ Getter method for label_restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction (list)
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ return self.__label_restriction
+
+ def _set_label_restriction(self, v, load=False):
+ """
+ Setter method for label_restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restriction() directly.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restriction must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__label_restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restriction(self):
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ label_restriction = __builtin__.property(_get_label_restriction, _set_label_restriction)
+
+
+ _pyangbind_elements = OrderedDict([('label_restriction', label_restriction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..be63791cbe8b06eb5b5c2f33c44b63bc06497851
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/__init__.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_start
+from . import label_end
+from . import label_step
+from . import otn_label_range
+from . import ethernet_label_range
+class label_restriction(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restriction','__index','__label_start','__label_end','__label_step','__range_bitmap','__otn_label_range','__ethernet_label_range',)
+
+ _yang_name = 'label-restriction'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction']
+
+ def _get_restriction(self):
+ """
+ Getter method for restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/restriction (enumeration)
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ return self.__restriction
+
+ def _set_restriction(self, v, load=False):
+ """
+ Setter method for restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/restriction (enumeration)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restriction() directly.
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restriction must be of a type compatible with enumeration""",
+ 'defined-type': "ietf-te-topology:enumeration",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)""",
+ })
+
+ self.__restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restriction(self):
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/index (uint32)
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_label_start(self):
+ """
+ Getter method for label_start, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start (container)
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ return self.__label_start
+
+ def _set_label_start(self, v, load=False):
+ """
+ Setter method for label_start, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_start is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_start() directly.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_start must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_start = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_start(self):
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_end(self):
+ """
+ Getter method for label_end, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end (container)
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ return self.__label_end
+
+ def _set_label_end(self, v, load=False):
+ """
+ Setter method for label_end, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_end is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_end() directly.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_end must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_end = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_end(self):
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_step(self):
+ """
+ Getter method for label_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step (container)
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ return self.__label_step
+
+ def _set_label_step(self, v, load=False):
+ """
+ Setter method for label_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_step() directly.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_step must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_step(self):
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_range_bitmap(self):
+ """
+ Getter method for range_bitmap, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ return self.__range_bitmap
+
+ def _set_range_bitmap(self, v, load=False):
+ """
+ Setter method for range_bitmap, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_bitmap is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_bitmap() directly.
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_bitmap must be of a type compatible with yang:hex-string""",
+ 'defined-type': "yang:hex-string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)""",
+ })
+
+ self.__range_bitmap = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_bitmap(self):
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+
+
+ def _get_otn_label_range(self):
+ """
+ Getter method for otn_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range (container)
+
+ YANG Description: Label range information for OTN.
+ """
+ return self.__otn_label_range
+
+ def _set_otn_label_range(self, v, load=False):
+ """
+ Setter method for otn_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_label_range() directly.
+
+ YANG Description: Label range information for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_label_range(self):
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_ethernet_label_range(self):
+ """
+ Getter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range (container)
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ return self.__ethernet_label_range
+
+ def _set_ethernet_label_range(self, v, load=False):
+ """
+ Setter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ethernet_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ethernet_label_range() directly.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ethernet_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__ethernet_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ethernet_label_range(self):
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ restriction = __builtin__.property(_get_restriction, _set_restriction)
+ index = __builtin__.property(_get_index, _set_index)
+ label_start = __builtin__.property(_get_label_start, _set_label_start)
+ label_end = __builtin__.property(_get_label_end, _set_label_end)
+ label_step = __builtin__.property(_get_label_step, _set_label_step)
+ range_bitmap = __builtin__.property(_get_range_bitmap, _set_range_bitmap)
+ otn_label_range = __builtin__.property(_get_otn_label_range, _set_otn_label_range)
+ ethernet_label_range = __builtin__.property(_get_ethernet_label_range, _set_ethernet_label_range)
+
+
+ _pyangbind_elements = OrderedDict([('restriction', restriction), ('index', index), ('label_start', label_start), ('label_end', label_end), ('label_step', label_step), ('range_bitmap', range_bitmap), ('otn_label_range', otn_label_range), ('ethernet_label_range', ethernet_label_range), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/ethernet_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/ethernet_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..85fe797a51b6fa7885f89cd65cf364ff57198576
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/ethernet_label_range/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ethernet_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/ethernet-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tag_type','__priority',)
+
+ _yang_name = 'ethernet-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'ethernet-label-range']
+
+ def _get_tag_type(self):
+ """
+ Getter method for tag_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+
+ YANG Description: VLAN tag type.
+ """
+ return self.__tag_type
+
+ def _set_tag_type(self, v, load=False):
+ """
+ Setter method for tag_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tag_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tag_type() directly.
+
+ YANG Description: VLAN tag type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tag_type must be of a type compatible with etht-types:eth-tag-type""",
+ 'defined-type': "etht-types:eth-tag-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)""",
+ })
+
+ self.__tag_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tag_type(self):
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+
+ YANG Description: priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ tag_type = __builtin__.property(_get_tag_type, _set_tag_type)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('tag_type', tag_type), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_end/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..3d944dc6d944eab6e6dac30513295005989a6f10
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_end/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_end(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-end. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-end'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-end']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..c0f426a02bd5be6f416217e24fbadf1b3f034ec2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-end/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-end', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..252392100dcf49782a2bf23a6abccca7c1af85c2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-end/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-end', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_start/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..7233908c119432a428f57f6e909caff23ae57867
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_start/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_start(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-start. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-start'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-start']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..c15cb8c1bb129f85fe29101fc8b1da2a3574ddc6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-start/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-start', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..29741fa5ec6c5d3bdaec7180d7371e8cd25a2aad
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-start/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-start', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_step/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..076a06d963d8ae945ad667fc4e57b3c7367688a6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_step/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class label_step(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-step. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_step',)
+
+ _yang_name = 'label-step'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-step']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/generic (int32)
+
+ YANG Description: Label range step.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/generic (int32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Label range step.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with int32""",
+ 'defined-type': "int32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn (container)
+
+ YANG Description: Label step for OTN
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label step for OTN
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_step(self):
+ """
+ Getter method for eth_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/eth_step (uint16)
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ return self.__eth_step
+
+ def _set_eth_step(self, v, load=False):
+ """
+ Setter method for eth_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/eth_step (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_step() directly.
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_step must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__eth_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_step(self):
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_step = __builtin__.property(_get_eth_step, _set_eth_step)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_step']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_step', eth_step), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_step/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_step/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..023f3d7553a6098ca6ace33091cb75002b4d0b52
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/label_step/otn/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/label-step/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label step for OTN
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'label-step', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/otn_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/otn_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e9f6bb66d506fa8ba26e0593d32ba8d4e697bfd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from_/label_restrictions/label_restriction/otn_label_range/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/from/label-restrictions/label-restriction/otn-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label range information for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__range_type','__tsg','__odu_type_list','__priority',)
+
+ _yang_name = 'otn-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'from', 'label-restrictions', 'label-restriction', 'otn-label-range']
+
+ def _get_range_type(self):
+ """
+ Getter method for range_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ return self.__range_type
+
+ def _set_range_type(self, v, load=False):
+ """
+ Setter method for range_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_type() directly.
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_type must be of a type compatible with otn-label-range-type""",
+ 'defined-type': "ietf-otn-topology:otn-label-range-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)""",
+ })
+
+ self.__range_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_type(self):
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_odu_type_list(self):
+ """
+ Getter method for odu_type_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ return self.__odu_type_list
+
+ def _set_odu_type_list(self, v, load=False):
+ """
+ Setter method for odu_type_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type_list() directly.
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type_list must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type_list(self):
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ range_type = __builtin__.property(_get_range_type, _set_range_type)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ odu_type_list = __builtin__.property(_get_odu_type_list, _set_odu_type_list)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('range_type', range_type), ('tsg', tsg), ('odu_type_list', odu_type_list), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dccc4ecbe42042d4634c694abf84c3a7b85602eb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/__init__.py
@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import optimization_metric
+from . import tiebreakers
+from . import objective_function
+class optimizations(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__optimization_metric','__tiebreakers','__objective_function',)
+
+ _yang_name = 'optimizations'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations']
+
+ def _get_optimization_metric(self):
+ """
+ Getter method for optimization_metric, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__optimization_metric
+
+ def _set_optimization_metric(self, v, load=False):
+ """
+ Setter method for optimization_metric, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimization_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimization_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimization_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__optimization_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimization_metric(self):
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+
+ def _get_tiebreakers(self):
+ """
+ Getter method for tiebreakers, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers (container)
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ return self.__tiebreakers
+
+ def _set_tiebreakers(self, v, load=False):
+ """
+ Setter method for tiebreakers, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreakers is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreakers() directly.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreakers must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tiebreakers = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreakers(self):
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_objective_function(self):
+ """
+ Getter method for objective_function, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/objective_function (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__objective_function
+
+ def _set_objective_function(self, v, load=False):
+ """
+ Setter method for objective_function, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/objective_function (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__objective_function = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function(self):
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ optimization_metric = __builtin__.property(_get_optimization_metric, _set_optimization_metric)
+ tiebreakers = __builtin__.property(_get_tiebreakers, _set_tiebreakers)
+ objective_function = __builtin__.property(_get_objective_function, _set_objective_function)
+
+ __choices__ = {'algorithm': {'metric': ['optimization_metric', 'tiebreakers'], 'objective-function': ['objective_function']}}
+ _pyangbind_elements = OrderedDict([('optimization_metric', optimization_metric), ('tiebreakers', tiebreakers), ('objective_function', objective_function), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/objective_function/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/objective_function/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd970e56fedbc68b634dc3dca1acb89ed8eb72e0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/objective_function/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class objective_function(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/objective-function. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__objective_function_type',)
+
+ _yang_name = 'objective-function'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'objective-function']
+
+ def _get_objective_function_type(self):
+ """
+ Getter method for objective_function_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/objective_function/objective_function_type (identityref)
+
+ YANG Description: Objective function entry.
+ """
+ return self.__objective_function_type
+
+ def _set_objective_function_type(self, v, load=False):
+ """
+ Setter method for objective_function_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/objective_function/objective_function_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function_type() directly.
+
+ YANG Description: Objective function entry.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__objective_function_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function_type(self):
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ objective_function_type = __builtin__.property(_get_objective_function_type, _set_objective_function_type)
+
+ __choices__ = {'algorithm': {'objective-function': ['objective_function_type']}}
+ _pyangbind_elements = OrderedDict([('objective_function_type', objective_function_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..63bedfaf58dd445b7d0fd52595841cada6de1b81
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/__init__.py
@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import explicit_route_exclude_objects
+from . import explicit_route_include_objects
+class optimization_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__weight','__explicit_route_exclude_objects','__explicit_route_include_objects',)
+
+ _yang_name = 'optimization-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/metric_type (identityref)
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_weight(self):
+ """
+ Getter method for weight, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/weight (uint8)
+
+ YANG Description: TE path metric normalization weight.
+ """
+ return self.__weight
+
+ def _set_weight(self, v, load=False):
+ """
+ Setter method for weight, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/weight (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_weight is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_weight() directly.
+
+ YANG Description: TE path metric normalization weight.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """weight must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__weight = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_weight(self):
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_explicit_route_exclude_objects(self):
+ """
+ Getter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ return self.__explicit_route_exclude_objects
+
+ def _set_explicit_route_exclude_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_exclude_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_exclude_objects() directly.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_exclude_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__explicit_route_exclude_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_exclude_objects(self):
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_explicit_route_include_objects(self):
+ """
+ Getter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects (container)
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ return self.__explicit_route_include_objects
+
+ def _set_explicit_route_include_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_include_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_include_objects() directly.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_include_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__explicit_route_include_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_include_objects(self):
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ metric_type = __builtin__.property(_get_metric_type, _set_metric_type)
+ weight = __builtin__.property(_get_weight, _set_weight)
+ explicit_route_exclude_objects = __builtin__.property(_get_explicit_route_exclude_objects, _set_explicit_route_exclude_objects)
+ explicit_route_include_objects = __builtin__.property(_get_explicit_route_include_objects, _set_explicit_route_include_objects)
+
+ __choices__ = {'algorithm': {'metric': ['metric_type', 'weight', 'explicit_route_exclude_objects', 'explicit_route_include_objects']}}
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('weight', weight), ('explicit_route_exclude_objects', explicit_route_exclude_objects), ('explicit_route_include_objects', explicit_route_include_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..07c1656b94e5163d64b0f1036db0f8140e211e9c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_exclude_object
+class explicit_route_exclude_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_exclude_object',)
+
+ _yang_name = 'explicit-route-exclude-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects']
+
+ def _get_route_object_exclude_object(self):
+ """
+ Getter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ return self.__route_object_exclude_object
+
+ def _set_route_object_exclude_object(self, v, load=False):
+ """
+ Setter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_exclude_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_exclude_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_exclude_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__route_object_exclude_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_exclude_object(self):
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ route_object_exclude_object = __builtin__.property(_get_route_object_exclude_object, _set_route_object_exclude_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_exclude_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_exclude_object', route_object_exclude_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a4f8fd0f12da75083b300b981aecd2de0064135
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
@@ -0,0 +1,365 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+from . import srlg
+class route_object_exclude_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop','__srlg',)
+
+ _yang_name = 'route-object-exclude-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+
+ YANG Description: SRLG container.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+ srlg = __builtin__.property(_get_srlg, _set_srlg)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop'], 'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..783159e5730b33eac6bc37c7fb7b130788e48fa7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..484b23ab16d64fc2e85f2a08d5088a4b720612e7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b55fb4219df570ca7341320f33241bc39119aa6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f11e3324ce91e692a6c2fd4cc46910282ee81a24
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..80a217af8cb58e9e70d92e7a00bce21021124e1c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..694b6a3c1719ef194c93b7968abed77ee1a6bf4d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a858772ed1f5c20466f998285c289d49b639c1c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py
@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class srlg(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/srlg. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: SRLG container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__srlg',)
+
+ _yang_name = 'srlg'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__srlg = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'srlg']
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/srlg (uint32)
+
+ YANG Description: SRLG value.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/srlg (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+ srlg = __builtin__.property(_get_srlg, _set_srlg)
+
+ __choices__ = {'type': {'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a0e2b21eb3ac9bffbea75fc9506ea0515a143ef
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cea85916d33dd2fabc77825f73e881e870076464
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_include_object
+class explicit_route_include_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_include_object',)
+
+ _yang_name = 'explicit-route-include-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_include_object = YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects']
+
+ def _get_route_object_include_object(self):
+ """
+ Getter method for route_object_include_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object (list)
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ return self.__route_object_include_object
+
+ def _set_route_object_include_object(self, v, load=False):
+ """
+ Setter method for route_object_include_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_include_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_include_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_include_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__route_object_include_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_include_object(self):
+ self.__route_object_include_object = YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ route_object_include_object = __builtin__.property(_get_route_object_include_object, _set_route_object_include_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_include_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_include_object', route_object_include_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1330f425e854ef75382319b9f405d41eb70e5c33
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py
@@ -0,0 +1,325 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class route_object_include_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'route-object-include-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..edcea596e308c1626e8607c772d43cb059fb63a3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..20d876129a9cfc163b39aadd15711ed2d468f771
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f3c37938006ce87bdfc57fed9bb4db41aac38ef
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9361ab75303485dba5e4181cbdb263ebec3d64f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e53b4266dbda6de34f5fae4186da419d8b942544
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f49e95c2a23dbd8805bee95422c2749ed04b9e48
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f69f0f6b7fba906111181eaa9b1944a184f064d1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0333aee2a52bc97afcc680872104618a2e09197
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tiebreaker
+class tiebreakers(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/tiebreakers. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tiebreaker',)
+
+ _yang_name = 'tiebreakers'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tiebreaker = YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'tiebreakers']
+
+ def _get_tiebreaker(self):
+ """
+ Getter method for tiebreaker, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker (list)
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ return self.__tiebreaker
+
+ def _set_tiebreaker(self, v, load=False):
+ """
+ Setter method for tiebreaker, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreaker is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreaker() directly.
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreaker must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__tiebreaker = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreaker(self):
+ self.__tiebreaker = YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ tiebreaker = __builtin__.property(_get_tiebreaker, _set_tiebreaker)
+
+ __choices__ = {'algorithm': {'metric': ['tiebreaker']}}
+ _pyangbind_elements = OrderedDict([('tiebreaker', tiebreaker), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..26464cef2cce0bf13cf6b910a5363e5d24215b20
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker/__init__.py
@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tiebreaker(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/optimizations/tiebreakers/tiebreaker. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tiebreaker_type',)
+
+ _yang_name = 'tiebreaker'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tiebreaker_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'optimizations', 'tiebreakers', 'tiebreaker']
+
+ def _get_tiebreaker_type(self):
+ """
+ Getter method for tiebreaker_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker/tiebreaker_type (identityref)
+
+ YANG Description: Identifies an entry in the list of tiebreakers.
+ """
+ return self.__tiebreaker_type
+
+ def _set_tiebreaker_type(self, v, load=False):
+ """
+ Setter method for tiebreaker_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/tiebreakers/tiebreaker/tiebreaker_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreaker_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreaker_type() directly.
+
+ YANG Description: Identifies an entry in the list of tiebreakers.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreaker_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tiebreaker_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreaker_type(self):
+ self.__tiebreaker_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ tiebreaker_type = __builtin__.property(_get_tiebreaker_type, _set_tiebreaker_type)
+
+ __choices__ = {'algorithm': {'metric': ['tiebreaker_type']}}
+ _pyangbind_elements = OrderedDict([('tiebreaker_type', tiebreaker_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b9f4b692f85c4789a24e5834c7eacdb19bb540f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py
@@ -0,0 +1,523 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+from . import path_metric_bounds
+from . import path_affinities_values
+from . import path_affinity_names
+from . import path_srlgs_lists
+from . import path_srlgs_names
+class path_constraints(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE named path constraints container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_bandwidth','__link_protection','__setup_priority','__hold_priority','__signaling_type','__path_metric_bounds','__path_affinities_values','__path_affinity_names','__path_srlgs_lists','__path_srlgs_names','__disjointness',)
+
+ _yang_name = 'path-constraints'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__link_protection = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__setup_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__hold_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__signaling_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__path_metric_bounds = YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__disjointness = YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints']
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_link_protection(self):
+ """
+ Getter method for link_protection, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/link_protection (identityref)
+
+ YANG Description: Link protection type required for the links included
+in the computed path.
+ """
+ return self.__link_protection
+
+ def _set_link_protection(self, v, load=False):
+ """
+ Setter method for link_protection, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/link_protection (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_protection is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_protection() directly.
+
+ YANG Description: Link protection type required for the links included
+in the computed path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_protection must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__link_protection = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_protection(self):
+ self.__link_protection = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_setup_priority(self):
+ """
+ Getter method for setup_priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/setup_priority (uint8)
+
+ YANG Description: TE LSP requested setup priority.
+ """
+ return self.__setup_priority
+
+ def _set_setup_priority(self, v, load=False):
+ """
+ Setter method for setup_priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/setup_priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_setup_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_setup_priority() directly.
+
+ YANG Description: TE LSP requested setup priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """setup_priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__setup_priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_setup_priority(self):
+ self.__setup_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_hold_priority(self):
+ """
+ Getter method for hold_priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/hold_priority (uint8)
+
+ YANG Description: TE LSP requested hold priority.
+ """
+ return self.__hold_priority
+
+ def _set_hold_priority(self, v, load=False):
+ """
+ Setter method for hold_priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/hold_priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hold_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hold_priority() directly.
+
+ YANG Description: TE LSP requested hold priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hold_priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__hold_priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hold_priority(self):
+ self.__hold_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_signaling_type(self):
+ """
+ Getter method for signaling_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/signaling_type (identityref)
+
+ YANG Description: TE tunnel path signaling type.
+ """
+ return self.__signaling_type
+
+ def _set_signaling_type(self, v, load=False):
+ """
+ Setter method for signaling_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/signaling_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_signaling_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_signaling_type() directly.
+
+ YANG Description: TE tunnel path signaling type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """signaling_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__signaling_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_signaling_type(self):
+ self.__signaling_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_path_metric_bounds(self):
+ """
+ Getter method for path_metric_bounds, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds (container)
+
+ YANG Description: TE path metric bounds container.
+ """
+ return self.__path_metric_bounds
+
+ def _set_path_metric_bounds(self, v, load=False):
+ """
+ Setter method for path_metric_bounds, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric_bounds is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric_bounds() directly.
+
+ YANG Description: TE path metric bounds container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric_bounds must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_metric_bounds = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric_bounds(self):
+ self.__path_metric_bounds = YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_affinities_values(self):
+ """
+ Getter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values (container)
+
+ YANG Description: Path affinities represented as values.
+ """
+ return self.__path_affinities_values
+
+ def _set_path_affinities_values(self, v, load=False):
+ """
+ Setter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_values() directly.
+
+ YANG Description: Path affinities represented as values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_values must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_affinities_values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_values(self):
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_affinity_names(self):
+ """
+ Getter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names (container)
+
+ YANG Description: Path affinities represented as names.
+ """
+ return self.__path_affinity_names
+
+ def _set_path_affinity_names(self, v, load=False):
+ """
+ Setter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_names() directly.
+
+ YANG Description: Path affinities represented as names.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_affinity_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_names(self):
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_srlgs_lists(self):
+ """
+ Getter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists (container)
+
+ YANG Description: Path SRLG properties container.
+ """
+ return self.__path_srlgs_lists
+
+ def _set_path_srlgs_lists(self, v, load=False):
+ """
+ Setter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_lists is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_lists() directly.
+
+ YANG Description: Path SRLG properties container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_lists must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_srlgs_lists = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_lists(self):
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_srlgs_names(self):
+ """
+ Getter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names (container)
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ return self.__path_srlgs_names
+
+ def _set_path_srlgs_names(self, v, load=False):
+ """
+ Setter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_names() directly.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_srlgs_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_names(self):
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_disjointness(self):
+ """
+ Getter method for disjointness, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/disjointness (te-path-disjointness)
+
+ YANG Description: The type of resource disjointness.
+When configured for a primary path, the disjointness level
+applies to all secondary LSPs. When configured for a
+secondary path, the disjointness level overrides the level
+configured for the primary path.
+ """
+ return self.__disjointness
+
+ def _set_disjointness(self, v, load=False):
+ """
+ Setter method for disjointness, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/disjointness (te-path-disjointness)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_disjointness is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_disjointness() directly.
+
+ YANG Description: The type of resource disjointness.
+When configured for a primary path, the disjointness level
+applies to all secondary LSPs. When configured for a
+secondary path, the disjointness level overrides the level
+configured for the primary path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """disjointness must be of a type compatible with te-path-disjointness""",
+ 'defined-type': "ietf-te-topology:te-path-disjointness",
+ 'generated-type': """YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)""",
+ })
+
+ self.__disjointness = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_disjointness(self):
+ self.__disjointness = YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)
+
+ te_bandwidth = __builtin__.property(_get_te_bandwidth, _set_te_bandwidth)
+ link_protection = __builtin__.property(_get_link_protection, _set_link_protection)
+ setup_priority = __builtin__.property(_get_setup_priority, _set_setup_priority)
+ hold_priority = __builtin__.property(_get_hold_priority, _set_hold_priority)
+ signaling_type = __builtin__.property(_get_signaling_type, _set_signaling_type)
+ path_metric_bounds = __builtin__.property(_get_path_metric_bounds, _set_path_metric_bounds)
+ path_affinities_values = __builtin__.property(_get_path_affinities_values, _set_path_affinities_values)
+ path_affinity_names = __builtin__.property(_get_path_affinity_names, _set_path_affinity_names)
+ path_srlgs_lists = __builtin__.property(_get_path_srlgs_lists, _set_path_srlgs_lists)
+ path_srlgs_names = __builtin__.property(_get_path_srlgs_names, _set_path_srlgs_names)
+ disjointness = __builtin__.property(_get_disjointness, _set_disjointness)
+
+
+ _pyangbind_elements = OrderedDict([('te_bandwidth', te_bandwidth), ('link_protection', link_protection), ('setup_priority', setup_priority), ('hold_priority', hold_priority), ('signaling_type', signaling_type), ('path_metric_bounds', path_metric_bounds), ('path_affinities_values', path_affinities_values), ('path_affinity_names', path_affinity_names), ('path_srlgs_lists', path_srlgs_lists), ('path_srlgs_names', path_srlgs_names), ('disjointness', disjointness), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..fbd5be1891af26f4906a30d7b8a19d836e7b69b7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinities_value
+class path_affinities_values(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-affinities-values. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as values.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinities_value',)
+
+ _yang_name = 'path-affinities-values'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-affinities-values']
+
+ def _get_path_affinities_value(self):
+ """
+ Getter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinities_value
+
+ def _set_path_affinities_value(self, v, load=False):
+ """
+ Setter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_value() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_value must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_affinities_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_value(self):
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_affinities_value = __builtin__.property(_get_path_affinities_value, _set_path_affinities_value)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinities_value', path_affinities_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..8c29e7d9cc37960b0ce075b3133f6ecd8370a441
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_affinities_value(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-affinities-values/path-affinities-value. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__value',)
+
+ _yang_name = 'path-affinities-value'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-affinities-values', 'path-affinities-value']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/value (admin-groups)
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/value (admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with admin-groups""",
+ 'defined-type': "ietf-te-topology:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ value = __builtin__.property(_get_value, _set_value)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..a8540d0a45dd2c5634ac4da048e47270f0b26782
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinity_name
+class path_affinity_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-affinity-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as names.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinity_name',)
+
+ _yang_name = 'path-affinity-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-affinity-names']
+
+ def _get_path_affinity_name(self):
+ """
+ Getter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinity_name
+
+ def _set_path_affinity_name(self, v, load=False):
+ """
+ Setter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_name() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_name(self):
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_affinity_name = __builtin__.property(_get_path_affinity_name, _set_path_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinity_name', path_affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..53d581fd6defd3f4698abb8ca0c2ee751c725608
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import affinity_name
+class path_affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-affinity-names/path-affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__affinity_name',)
+
+ _yang_name = 'path-affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-affinity-names', 'path-affinity-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_affinity_name(self):
+ """
+ Getter method for affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name (list)
+
+ YANG Description: List of named affinities.
+ """
+ return self.__affinity_name
+
+ def _set_affinity_name(self, v, load=False):
+ """
+ Setter method for affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_affinity_name() directly.
+
+ YANG Description: List of named affinities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_affinity_name(self):
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ affinity_name = __builtin__.property(_get_affinity_name, _set_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('affinity_name', affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..9049a13907bb3f9c4ba5aab6782e77a5a6a26bc1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-affinity-names/path-affinity-name/affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__name',)
+
+ _yang_name = 'affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-affinity-names', 'path-affinity-name', 'affinity-name']
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name/name (string)
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ name = __builtin__.property(_get_name, _set_name)
+
+
+ _pyangbind_elements = OrderedDict([('name', name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..7f6acfbb0d20361ab8b7c406ceb4fef2d4a868e9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_metric_bound
+class path_metric_bounds(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-metric-bounds. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric bounds container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_metric_bound',)
+
+ _yang_name = 'path-metric-bounds'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_metric_bound = YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-metric-bounds']
+
+ def _get_path_metric_bound(self):
+ """
+ Getter method for path_metric_bound, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound (list)
+
+ YANG Description: List of TE path metric bounds.
+ """
+ return self.__path_metric_bound
+
+ def _set_path_metric_bound(self, v, load=False):
+ """
+ Setter method for path_metric_bound, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric_bound is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric_bound() directly.
+
+ YANG Description: List of TE path metric bounds.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric_bound must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_metric_bound = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric_bound(self):
+ self.__path_metric_bound = YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_metric_bound = __builtin__.property(_get_path_metric_bound, _set_path_metric_bound)
+
+
+ _pyangbind_elements = OrderedDict([('path_metric_bound', path_metric_bound), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..177598e6cc98b222f75deb7968076fc9fdc39c66
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,165 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_metric_bound(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-metric-bounds/path-metric-bound. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of TE path metric bounds.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__upper_bound',)
+
+ _yang_name = 'path-metric-bound'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__upper_bound = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-metric-bounds', 'path-metric-bound']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/metric_type (identityref)
+
+ YANG Description: Identifies an entry in the list of 'metric-type' items
+bound for the TE path.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies an entry in the list of 'metric-type' items
+bound for the TE path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_upper_bound(self):
+ """
+ Getter method for upper_bound, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/upper_bound (uint64)
+
+ YANG Description: Upper bound on the end-to-end TE path metric. A zero
+indicates an unbounded upper limit for the specific
+'metric-type'.
+ """
+ return self.__upper_bound
+
+ def _set_upper_bound(self, v, load=False):
+ """
+ Setter method for upper_bound, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/upper_bound (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_upper_bound is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_upper_bound() directly.
+
+ YANG Description: Upper bound on the end-to-end TE path metric. A zero
+indicates an unbounded upper limit for the specific
+'metric-type'.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """upper_bound must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__upper_bound = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_upper_bound(self):
+ self.__upper_bound = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+
+ metric_type = __builtin__.property(_get_metric_type, _set_metric_type)
+ upper_bound = __builtin__.property(_get_upper_bound, _set_upper_bound)
+
+
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('upper_bound', upper_bound), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..9a345c8aea6c5d92701fd78223bdfa27f3a4d1df
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_list
+class path_srlgs_lists(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-srlgs-lists. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path SRLG properties container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_list',)
+
+ _yang_name = 'path-srlgs-lists'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-srlgs-lists']
+
+ def _get_path_srlgs_list(self):
+ """
+ Getter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list (list)
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ return self.__path_srlgs_list
+
+ def _set_path_srlgs_list(self, v, load=False):
+ """
+ Setter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_list() directly.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_list must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_srlgs_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_list(self):
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_srlgs_list = __builtin__.property(_get_path_srlgs_list, _set_path_srlgs_list)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_list', path_srlgs_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..42bd453b07b8d361fdf87021cebdd01f32a44a50
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_list(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-srlgs-lists/path-srlgs-list. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__values',)
+
+ _yang_name = 'path-srlgs-list'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-srlgs-lists', 'path-srlgs-list']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_values(self):
+ """
+ Getter method for values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/values (srlg)
+
+ YANG Description: List of SRLG values.
+ """
+ return self.__values
+
+ def _set_values(self, v, load=False):
+ """
+ Setter method for values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/values (srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_values() directly.
+
+ YANG Description: List of SRLG values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """values must be of a type compatible with srlg""",
+ 'defined-type': "ietf-te-topology:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)""",
+ })
+
+ self.__values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_values(self):
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ values = __builtin__.property(_get_values, _set_values)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('values', values), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..83edd896faaa58e47f59aa341f7656bc96a59e42
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_name
+class path_srlgs_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-srlgs-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_name',)
+
+ _yang_name = 'path-srlgs-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-srlgs-names']
+
+ def _get_path_srlgs_name(self):
+ """
+ Getter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name (list)
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ return self.__path_srlgs_name
+
+ def _set_path_srlgs_name(self, v, load=False):
+ """
+ Setter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_name() directly.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_srlgs_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_name(self):
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_srlgs_name = __builtin__.property(_get_path_srlgs_name, _set_path_srlgs_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_name', path_srlgs_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..7dba34db6f2d139b3396c6fd9a93ce926bab1a69
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/path-srlgs-names/path-srlgs-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__names',)
+
+ _yang_name = 'path-srlgs-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'path-srlgs-names', 'path-srlgs-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_names(self):
+ """
+ Getter method for names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/names (string)
+
+ YANG Description: List of named SRLGs.
+ """
+ return self.__names
+
+ def _set_names(self, v, load=False):
+ """
+ Setter method for names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/names (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_names() directly.
+
+ YANG Description: List of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """names must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_names(self):
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ names = __builtin__.property(_get_names, _set_names)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('names', names), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4e10c8b6b05ce85c5ec52494d78dd67f10eed2e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth, _set_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_bandwidth']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2a8fce28fa658133b7b416804f64dbe6aa29642
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/__init__.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist','__odtu_flex_type',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+
+
+ def _get_odtu_flex_type(self):
+ """
+ Getter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+set up along the underlay path of this OTN
+connectivity matrix entry.
+ """
+ return self.__odtu_flex_type
+
+ def _set_odtu_flex_type(self, v, load=False):
+ """
+ Setter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odtu_flex_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odtu_flex_type() directly.
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+set up along the underlay path of this OTN
+connectivity matrix entry.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odtu_flex_type must be of a type compatible with l1-types:odtu-flex-type""",
+ 'defined-type': "l1-types:odtu-flex-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)""",
+ })
+
+ self.__odtu_flex_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odtu_flex_type(self):
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+
+ odulist = __builtin__.property(_get_odulist, _set_odulist)
+ odtu_flex_type = __builtin__.property(_get_odtu_flex_type, _set_odtu_flex_type)
+
+ __choices__ = {'technology': {'otn': ['odulist', 'odtu_flex_type']}}
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ('odtu_flex_type', odtu_flex_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9923938e39446c8970698126ec0670cd424a8b35
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-constraints/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-constraints', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ odu_type = __builtin__.property(_get_odu_type, _set_odu_type)
+ number = __builtin__.property(_get_number, _set_number)
+ ts_number = __builtin__.property(_get_ts_number, _set_ts_number)
+
+ __choices__ = {'technology': {'otn': ['odu_type', 'number', 'ts_number']}}
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..32bb9a55344f0995388f9d85a42c05850802c125
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/__init__.py
@@ -0,0 +1,318 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_metric
+from . import path_affinities_values
+from . import path_affinity_names
+from . import path_srlgs_lists
+from . import path_srlgs_names
+from . import path_route_objects
+class path_properties(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The TE path properties.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_metric','__path_affinities_values','__path_affinity_names','__path_srlgs_lists','__path_srlgs_names','__path_route_objects',)
+
+ _yang_name = 'path-properties'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_metric = YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_route_objects = YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties']
+
+ def _get_path_metric(self):
+ """
+ Getter method for path_metric, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__path_metric
+
+ def _set_path_metric(self, v, load=False):
+ """
+ Setter method for path_metric, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric(self):
+ self.__path_metric = YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_path_affinities_values(self):
+ """
+ Getter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values (container)
+
+ YANG Description: Path affinities represented as values.
+ """
+ return self.__path_affinities_values
+
+ def _set_path_affinities_values(self, v, load=False):
+ """
+ Setter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_values() directly.
+
+ YANG Description: Path affinities represented as values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_values must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinities_values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_values(self):
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_affinity_names(self):
+ """
+ Getter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names (container)
+
+ YANG Description: Path affinities represented as names.
+ """
+ return self.__path_affinity_names
+
+ def _set_path_affinity_names(self, v, load=False):
+ """
+ Setter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_names() directly.
+
+ YANG Description: Path affinities represented as names.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinity_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_names(self):
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_lists(self):
+ """
+ Getter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists (container)
+
+ YANG Description: Path SRLG properties container.
+ """
+ return self.__path_srlgs_lists
+
+ def _set_path_srlgs_lists(self, v, load=False):
+ """
+ Setter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_lists is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_lists() directly.
+
+ YANG Description: Path SRLG properties container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_lists must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_lists = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_lists(self):
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_names(self):
+ """
+ Getter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names (container)
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ return self.__path_srlgs_names
+
+ def _set_path_srlgs_names(self, v, load=False):
+ """
+ Setter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_names() directly.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_names(self):
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_route_objects(self):
+ """
+ Getter method for path_route_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects (container)
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ return self.__path_route_objects
+
+ def _set_path_route_objects(self, v, load=False):
+ """
+ Setter method for path_route_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_route_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_route_objects() directly.
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_route_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_route_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_route_objects(self):
+ self.__path_route_objects = YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ path_metric = __builtin__.property(_get_path_metric)
+ path_affinities_values = __builtin__.property(_get_path_affinities_values)
+ path_affinity_names = __builtin__.property(_get_path_affinity_names)
+ path_srlgs_lists = __builtin__.property(_get_path_srlgs_lists)
+ path_srlgs_names = __builtin__.property(_get_path_srlgs_names)
+ path_route_objects = __builtin__.property(_get_path_route_objects)
+
+
+ _pyangbind_elements = OrderedDict([('path_metric', path_metric), ('path_affinities_values', path_affinities_values), ('path_affinity_names', path_affinity_names), ('path_srlgs_lists', path_srlgs_lists), ('path_srlgs_names', path_srlgs_names), ('path_route_objects', path_route_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..a7001481d1fe05d745191fdb31eca30831060363
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinities_value
+class path_affinities_values(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-affinities-values. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as values.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinities_value',)
+
+ _yang_name = 'path-affinities-values'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-affinities-values']
+
+ def _get_path_affinities_value(self):
+ """
+ Getter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinities_value
+
+ def _set_path_affinities_value(self, v, load=False):
+ """
+ Setter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_value() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_value must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinities_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_value(self):
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinities_value = __builtin__.property(_get_path_affinities_value)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinities_value', path_affinities_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..d762b99905ba2f4da909cbd5a9598f288201a26a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_affinities_value(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-affinities-values/path-affinities-value. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__value',)
+
+ _yang_name = 'path-affinities-value'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-affinities-values', 'path-affinities-value']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/value (admin-groups)
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/value (admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with admin-groups""",
+ 'defined-type': "ietf-te-topology:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ value = __builtin__.property(_get_value)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..76beb2d043e11712fd3250aba4b173cb346ef2a2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinity_name
+class path_affinity_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-affinity-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as names.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinity_name',)
+
+ _yang_name = 'path-affinity-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-affinity-names']
+
+ def _get_path_affinity_name(self):
+ """
+ Getter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinity_name
+
+ def _set_path_affinity_name(self, v, load=False):
+ """
+ Setter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_name() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_name(self):
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinity_name = __builtin__.property(_get_path_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinity_name', path_affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..04f8c534e27f69735f535d5f843ca92a6b49cb57
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import affinity_name
+class path_affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-affinity-names/path-affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__affinity_name',)
+
+ _yang_name = 'path-affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-affinity-names', 'path-affinity-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_affinity_name(self):
+ """
+ Getter method for affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name (list)
+
+ YANG Description: List of named affinities.
+ """
+ return self.__affinity_name
+
+ def _set_affinity_name(self, v, load=False):
+ """
+ Setter method for affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_affinity_name() directly.
+
+ YANG Description: List of named affinities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_affinity_name(self):
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ affinity_name = __builtin__.property(_get_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('affinity_name', affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..c8ffc56297616e8c0ef51adc8c6259cdff46a40c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-affinity-names/path-affinity-name/affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__name',)
+
+ _yang_name = 'affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-affinity-names', 'path-affinity-name', 'affinity-name']
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name/name (string)
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ name = __builtin__.property(_get_name)
+
+
+ _pyangbind_elements = OrderedDict([('name', name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6bea27715a4189f606ae688a2d7c9669622fd8eb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py
@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__accumulative_value',)
+
+ _yang_name = 'path-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__accumulative_value = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric/metric_type (identityref)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: TE path metric type.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_accumulative_value(self):
+ """
+ Getter method for accumulative_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric/accumulative_value (uint64)
+
+ YANG Description: TE path metric accumulative value.
+ """
+ return self.__accumulative_value
+
+ def _set_accumulative_value(self, v, load=False):
+ """
+ Setter method for accumulative_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric/accumulative_value (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_accumulative_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_accumulative_value() directly.
+
+ YANG Description: TE path metric accumulative value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """accumulative_value must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__accumulative_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_accumulative_value(self):
+ self.__accumulative_value = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ metric_type = __builtin__.property(_get_metric_type)
+ accumulative_value = __builtin__.property(_get_accumulative_value)
+
+
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('accumulative_value', accumulative_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..fb3b4a46db89df48d7ecd89e13f170acb5408422
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_route_object
+class path_route_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_route_object',)
+
+ _yang_name = 'path-route-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_route_object = YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects']
+
+ def _get_path_route_object(self):
+ """
+ Getter method for path_route_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object (list)
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ return self.__path_route_object
+
+ def _set_path_route_object(self, v, load=False):
+ """
+ Setter method for path_route_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_route_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_route_object() directly.
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_route_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_route_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_route_object(self):
+ self.__path_route_object = YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_route_object = __builtin__.property(_get_path_route_object)
+
+
+ _pyangbind_elements = OrderedDict([('path_route_object', path_route_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..4fe9aa220c102f6cab8ad5d063130942e104a057
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,327 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_route_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-route-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key
+values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key
+values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..11ddae41732894db4171b3106af40634574da943
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7440b873293ac0528b33accb58edf95a7c6a562b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fc49cf759876cd11163a8421fb14c132f5d2909
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d758b29226ac9b1c81c34b3c87bb7073301fcb4a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1a29aebbc711d38d528577295264d3d5c3dba83
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ca5c4eec4cb58ba2efcd873b465fe51825cc7a2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ec157d352f1bbfa6708487d795d11781a395aa0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-route-objects/path-route-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-route-objects', 'path-route-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..e509790c476b91a55c605ae6848e7eb92fa72aaa
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_list
+class path_srlgs_lists(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-srlgs-lists. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path SRLG properties container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_list',)
+
+ _yang_name = 'path-srlgs-lists'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-srlgs-lists']
+
+ def _get_path_srlgs_list(self):
+ """
+ Getter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list (list)
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ return self.__path_srlgs_list
+
+ def _set_path_srlgs_list(self, v, load=False):
+ """
+ Setter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_list() directly.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_list must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_list(self):
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_list = __builtin__.property(_get_path_srlgs_list)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_list', path_srlgs_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..37a85c235cb877b698286f524cb2bd949e72954c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_list(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-srlgs-lists/path-srlgs-list. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__values',)
+
+ _yang_name = 'path-srlgs-list'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-srlgs-lists', 'path-srlgs-list']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_values(self):
+ """
+ Getter method for values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/values (srlg)
+
+ YANG Description: List of SRLG values.
+ """
+ return self.__values
+
+ def _set_values(self, v, load=False):
+ """
+ Setter method for values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/values (srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_values() directly.
+
+ YANG Description: List of SRLG values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """values must be of a type compatible with srlg""",
+ 'defined-type': "ietf-te-topology:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)""",
+ })
+
+ self.__values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_values(self):
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ values = __builtin__.property(_get_values)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('values', values), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..4e96bae2f4b7f9606d0cfe24d4b04fc9e59dd9f5
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_name
+class path_srlgs_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-srlgs-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_name',)
+
+ _yang_name = 'path-srlgs-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-srlgs-names']
+
+ def _get_path_srlgs_name(self):
+ """
+ Getter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name (list)
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ return self.__path_srlgs_name
+
+ def _set_path_srlgs_name(self, v, load=False):
+ """
+ Setter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_name() directly.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_name(self):
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_name = __builtin__.property(_get_path_srlgs_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_name', path_srlgs_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..ec8734fe06d3243c84ca236814d5f8b92e86c609
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/path-properties/path-srlgs-names/path-srlgs-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__names',)
+
+ _yang_name = 'path-srlgs-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'path-properties', 'path-srlgs-names', 'path-srlgs-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_names(self):
+ """
+ Getter method for names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/names (string)
+
+ YANG Description: List of named SRLGs.
+ """
+ return self.__names
+
+ def _set_names(self, v, load=False):
+ """
+ Setter method for names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/names (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_names() directly.
+
+ YANG Description: List of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """names must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_names(self):
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ names = __builtin__.property(_get_names)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('names', names), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fb67245815d19b30ad2a40dcfbd566f0bf3cdba
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/__init__.py
@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restrictions
+class to(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Reference to a destination LTP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tp_ref','__label_restrictions',)
+
+ _yang_name = 'to'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to']
+
+ def _get_tp_ref(self):
+ """
+ Getter method for tp_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/tp_ref (leafref)
+
+ YANG Description: Relative reference to a termination point.
+ """
+ return self.__tp_ref
+
+ def _set_tp_ref(self, v, load=False):
+ """
+ Setter method for tp_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/tp_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tp_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tp_ref() directly.
+
+ YANG Description: Relative reference to a termination point.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tp_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__tp_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tp_ref(self):
+ self.__tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_label_restrictions(self):
+ """
+ Getter method for label_restrictions, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions (container)
+
+ YANG Description: The label restrictions container.
+ """
+ return self.__label_restrictions
+
+ def _set_label_restrictions(self, v, load=False):
+ """
+ Setter method for label_restrictions, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restrictions is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restrictions() directly.
+
+ YANG Description: The label restrictions container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restrictions must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_restrictions = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restrictions(self):
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ tp_ref = __builtin__.property(_get_tp_ref, _set_tp_ref)
+ label_restrictions = __builtin__.property(_get_label_restrictions, _set_label_restrictions)
+
+
+ _pyangbind_elements = OrderedDict([('tp_ref', tp_ref), ('label_restrictions', label_restrictions), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8dfdb0a632d537ad52e29f5519c6f72b4dce979d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restriction
+class label_restrictions(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The label restrictions container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__label_restriction',)
+
+ _yang_name = 'label-restrictions'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions']
+
+ def _get_label_restriction(self):
+ """
+ Getter method for label_restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction (list)
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ return self.__label_restriction
+
+ def _set_label_restriction(self, v, load=False):
+ """
+ Setter method for label_restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restriction() directly.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restriction must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__label_restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restriction(self):
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ label_restriction = __builtin__.property(_get_label_restriction, _set_label_restriction)
+
+
+ _pyangbind_elements = OrderedDict([('label_restriction', label_restriction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..3b116c4b7203064fe2844ac60d195517e8aed8a0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/__init__.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_start
+from . import label_end
+from . import label_step
+from . import otn_label_range
+from . import ethernet_label_range
+class label_restriction(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restriction','__index','__label_start','__label_end','__label_step','__range_bitmap','__otn_label_range','__ethernet_label_range',)
+
+ _yang_name = 'label-restriction'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction']
+
+ def _get_restriction(self):
+ """
+ Getter method for restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/restriction (enumeration)
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ return self.__restriction
+
+ def _set_restriction(self, v, load=False):
+ """
+ Setter method for restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/restriction (enumeration)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restriction() directly.
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restriction must be of a type compatible with enumeration""",
+ 'defined-type': "ietf-te-topology:enumeration",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)""",
+ })
+
+ self.__restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restriction(self):
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/index (uint32)
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_label_start(self):
+ """
+ Getter method for label_start, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start (container)
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ return self.__label_start
+
+ def _set_label_start(self, v, load=False):
+ """
+ Setter method for label_start, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_start is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_start() directly.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_start must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_start = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_start(self):
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_end(self):
+ """
+ Getter method for label_end, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end (container)
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ return self.__label_end
+
+ def _set_label_end(self, v, load=False):
+ """
+ Setter method for label_end, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_end is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_end() directly.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_end must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_end = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_end(self):
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_step(self):
+ """
+ Getter method for label_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step (container)
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ return self.__label_step
+
+ def _set_label_step(self, v, load=False):
+ """
+ Setter method for label_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_step() directly.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_step must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_step(self):
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_range_bitmap(self):
+ """
+ Getter method for range_bitmap, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ return self.__range_bitmap
+
+ def _set_range_bitmap(self, v, load=False):
+ """
+ Setter method for range_bitmap, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_bitmap is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_bitmap() directly.
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_bitmap must be of a type compatible with yang:hex-string""",
+ 'defined-type': "yang:hex-string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)""",
+ })
+
+ self.__range_bitmap = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_bitmap(self):
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+
+
+ def _get_otn_label_range(self):
+ """
+ Getter method for otn_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range (container)
+
+ YANG Description: Label range information for OTN.
+ """
+ return self.__otn_label_range
+
+ def _set_otn_label_range(self, v, load=False):
+ """
+ Setter method for otn_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_label_range() directly.
+
+ YANG Description: Label range information for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_label_range(self):
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_ethernet_label_range(self):
+ """
+ Getter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range (container)
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ return self.__ethernet_label_range
+
+ def _set_ethernet_label_range(self, v, load=False):
+ """
+ Setter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ethernet_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ethernet_label_range() directly.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ethernet_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__ethernet_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ethernet_label_range(self):
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ restriction = __builtin__.property(_get_restriction, _set_restriction)
+ index = __builtin__.property(_get_index, _set_index)
+ label_start = __builtin__.property(_get_label_start, _set_label_start)
+ label_end = __builtin__.property(_get_label_end, _set_label_end)
+ label_step = __builtin__.property(_get_label_step, _set_label_step)
+ range_bitmap = __builtin__.property(_get_range_bitmap, _set_range_bitmap)
+ otn_label_range = __builtin__.property(_get_otn_label_range, _set_otn_label_range)
+ ethernet_label_range = __builtin__.property(_get_ethernet_label_range, _set_ethernet_label_range)
+
+
+ _pyangbind_elements = OrderedDict([('restriction', restriction), ('index', index), ('label_start', label_start), ('label_end', label_end), ('label_step', label_step), ('range_bitmap', range_bitmap), ('otn_label_range', otn_label_range), ('ethernet_label_range', ethernet_label_range), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9f4959da8dd27c33cc032ea7aeca7187983defb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ethernet_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/ethernet-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tag_type','__priority',)
+
+ _yang_name = 'ethernet-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'ethernet-label-range']
+
+ def _get_tag_type(self):
+ """
+ Getter method for tag_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+
+ YANG Description: VLAN tag type.
+ """
+ return self.__tag_type
+
+ def _set_tag_type(self, v, load=False):
+ """
+ Setter method for tag_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tag_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tag_type() directly.
+
+ YANG Description: VLAN tag type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tag_type must be of a type compatible with etht-types:eth-tag-type""",
+ 'defined-type': "etht-types:eth-tag-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)""",
+ })
+
+ self.__tag_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tag_type(self):
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+
+ YANG Description: priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ tag_type = __builtin__.property(_get_tag_type, _set_tag_type)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('tag_type', tag_type), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..c5f363333d09d75e388c31ad02dc35dd6738a649
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_end(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-end. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-end'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-end']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..09a0f03ed1a0b6b77fb1d353db37895d11f535cc
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-end/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-end', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..74637ab69ead2142e633f02a0086d84b0c7399c5
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-end/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-end', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..55e8ab30e76fcc82c40609ad33db4cdf7a3ae37a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_start(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-start. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-start'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-start']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..c2477e8170b56ab2a83195bd4ad0c64a4bd8e5f0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-start/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-start', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbb3ec6163a997eae9f05b52925b3499d13241f4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-start/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-start', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..570cd69b5233c732d475c31c8e317363f842c6a9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class label_step(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-step. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_step',)
+
+ _yang_name = 'label-step'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-step']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/generic (int32)
+
+ YANG Description: Label range step.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/generic (int32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Label range step.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with int32""",
+ 'defined-type': "int32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn (container)
+
+ YANG Description: Label step for OTN
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label step for OTN
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_step(self):
+ """
+ Getter method for eth_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/eth_step (uint16)
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ return self.__eth_step
+
+ def _set_eth_step(self, v, load=False):
+ """
+ Setter method for eth_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/eth_step (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_step() directly.
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_step must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__eth_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_step(self):
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_step = __builtin__.property(_get_eth_step, _set_eth_step)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_step']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_step', eth_step), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..541e342528410f5d656bd32efa173b3db4013a54
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/label-step/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label step for OTN
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'label-step', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cae8d9a9e2770de2123e7db9d9bbe96a2864df4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/to/label-restrictions/label-restriction/otn-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label range information for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__range_type','__tsg','__odu_type_list','__priority',)
+
+ _yang_name = 'otn-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'to', 'label-restrictions', 'label-restriction', 'otn-label-range']
+
+ def _get_range_type(self):
+ """
+ Getter method for range_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ return self.__range_type
+
+ def _set_range_type(self, v, load=False):
+ """
+ Setter method for range_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_type() directly.
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_type must be of a type compatible with otn-label-range-type""",
+ 'defined-type': "ietf-otn-topology:otn-label-range-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)""",
+ })
+
+ self.__range_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_type(self):
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_odu_type_list(self):
+ """
+ Getter method for odu_type_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ return self.__odu_type_list
+
+ def _set_odu_type_list(self, v, load=False):
+ """
+ Setter method for odu_type_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type_list() directly.
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type_list must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type_list(self):
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ range_type = __builtin__.property(_get_range_type, _set_range_type)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ odu_type_list = __builtin__.property(_get_odu_type_list, _set_odu_type_list)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('range_type', range_type), ('tsg', tsg), ('odu_type_list', odu_type_list), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..29a2ea0fd8a120ff5357eadcd7a19e02b090f71c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/__init__.py
@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import primary_path
+from . import backup_path
+from . import tunnel_termination_points
+from . import tunnels
+class underlay(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__enabled','__primary_path','__backup_path','__protection_type','__tunnel_termination_points','__tunnels',)
+
+ _yang_name = 'underlay'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay']
+
+ def _get_enabled(self):
+ """
+ Getter method for enabled, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/enabled (boolean)
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ return self.__enabled
+
+ def _set_enabled(self, v, load=False):
+ """
+ Setter method for enabled, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/enabled (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_enabled is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_enabled() directly.
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """enabled must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__enabled = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_enabled(self):
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_primary_path(self):
+ """
+ Getter method for primary_path, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path (container)
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ return self.__primary_path
+
+ def _set_primary_path(self, v, load=False):
+ """
+ Setter method for primary_path, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_primary_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_primary_path() directly.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """primary_path must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__primary_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_primary_path(self):
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_backup_path(self):
+ """
+ Getter method for backup_path, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path (list)
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ return self.__backup_path
+
+ def _set_backup_path(self, v, load=False):
+ """
+ Setter method for backup_path, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_backup_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_backup_path() directly.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """backup_path must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__backup_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_backup_path(self):
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+
+ def _get_protection_type(self):
+ """
+ Getter method for protection_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/protection_type (identityref)
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ return self.__protection_type
+
+ def _set_protection_type(self, v, load=False):
+ """
+ Setter method for protection_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/protection_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_protection_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_protection_type() directly.
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """protection_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__protection_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_protection_type(self):
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_tunnel_termination_points(self):
+ """
+ Getter method for tunnel_termination_points, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points (container)
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ return self.__tunnel_termination_points
+
+ def _set_tunnel_termination_points(self, v, load=False):
+ """
+ Setter method for tunnel_termination_points, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_termination_points is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_termination_points() directly.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_termination_points must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tunnel_termination_points = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_termination_points(self):
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_tunnels(self):
+ """
+ Getter method for tunnels, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels (container)
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ return self.__tunnels
+
+ def _set_tunnels(self, v, load=False):
+ """
+ Setter method for tunnels, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnels is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnels() directly.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnels must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tunnels = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnels(self):
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ enabled = __builtin__.property(_get_enabled, _set_enabled)
+ primary_path = __builtin__.property(_get_primary_path, _set_primary_path)
+ backup_path = __builtin__.property(_get_backup_path, _set_backup_path)
+ protection_type = __builtin__.property(_get_protection_type, _set_protection_type)
+ tunnel_termination_points = __builtin__.property(_get_tunnel_termination_points, _set_tunnel_termination_points)
+ tunnels = __builtin__.property(_get_tunnels, _set_tunnels)
+
+
+ _pyangbind_elements = OrderedDict([('enabled', enabled), ('primary_path', primary_path), ('backup_path', backup_path), ('protection_type', protection_type), ('tunnel_termination_points', tunnel_termination_points), ('tunnels', tunnels), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..408b97bc6385509bb3f83e109e4e0844f41279c8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py
@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class backup_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/backup-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__network_ref','__path_element',)
+
+ _yang_name = 'backup-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/index (uint32)
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element (list)
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ path_element = __builtin__.property(_get_path_element, _set_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('index', index), ('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..53ca0bce54916db7b6469583d2b92a3536e62920
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/__init__.py
@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ path_element_id = __builtin__.property(_get_path_element_id, _set_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0ecb1150e0d73ba14866319d4cd5f2cd9e58074
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbd8c31c17338968331ab95064ad2e7cbad80466
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b13105528e3d923437202a96c9dbff4bab19baa
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..92e4b3b2009cee10fae7ccac4d4d8ddfed3559a1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee5484d4dc425abb7f30cb8d93b754e6b2c583f2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f2167210db07f6173864a9243c607caf84af8da5
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d48ba9d72ca9ea519dcaf0af21dd99f7f5a8780
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/backup-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'backup-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f2bbc86b5c77f178913fdd770dc8971277d5c31c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class primary_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/primary-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref','__path_element',)
+
+ _yang_name = 'primary-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element (list)
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ path_element = __builtin__.property(_get_path_element, _set_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..fa22d7bbd2819b292006ab4f290008b98fba9a86
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/__init__.py
@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ path_element_id = __builtin__.property(_get_path_element_id, _set_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bf46184c7e5d536c281b66407774448ecff1a55
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6377790bb6bae1df14603a8b0ac6aeac4067e877
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c200f5daec410e22c5714ac6244580fb2af5d8ca
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f897420e3ffe30a72d157d79095f9d5e5287436
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1c306281f6a074eb7204e1ab31f818f01529c60
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c043b2727a232d8eb3ccbefecc4ff22b49135b6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f8f2de6e21f868f30d26149c233125f23b9415f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/primary-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'primary-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fbb783c1fd354a14fab78d0f5e41ca5efd857a1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel_termination_points(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/tunnel-termination-points. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__source','__destination',)
+
+ _yang_name = 'tunnel-termination-points'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'tunnel-termination-points']
+
+ def _get_source(self):
+ """
+ Getter method for source, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/source (binary)
+
+ YANG Description: Source TTP identifier.
+ """
+ return self.__source
+
+ def _set_source(self, v, load=False):
+ """
+ Setter method for source, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/source (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_source() directly.
+
+ YANG Description: Source TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """source must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)""",
+ })
+
+ self.__source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_source(self):
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+
+ def _get_destination(self):
+ """
+ Getter method for destination, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/destination (binary)
+
+ YANG Description: Destination TTP identifier.
+ """
+ return self.__destination
+
+ def _set_destination(self, v, load=False):
+ """
+ Setter method for destination, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/destination (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_destination is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_destination() directly.
+
+ YANG Description: Destination TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """destination must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)""",
+ })
+
+ self.__destination = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_destination(self):
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+ source = __builtin__.property(_get_source, _set_source)
+ destination = __builtin__.property(_get_destination, _set_destination)
+
+
+ _pyangbind_elements = OrderedDict([('source', source), ('destination', destination), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5455155f401d092644389695e8ddd28e47cbef6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py
@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tunnel
+class tunnels(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/tunnels. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__sharing','__tunnel',)
+
+ _yang_name = 'tunnels'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'tunnels']
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_tunnel(self):
+ """
+ Getter method for tunnel, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel (list)
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ return self.__tunnel
+
+ def _set_tunnel(self, v, load=False):
+ """
+ Setter method for tunnel, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel() directly.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__tunnel = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel(self):
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ sharing = __builtin__.property(_get_sharing, _set_sharing)
+ tunnel = __builtin__.property(_get_tunnel, _set_tunnel)
+
+
+ _pyangbind_elements = OrderedDict([('sharing', sharing), ('tunnel', tunnel), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..58c254b1efbb56273d6c8f522441dd540741f72a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/connectivity-matrix/underlay/tunnels/tunnel. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tunnel_name','__sharing',)
+
+ _yang_name = 'tunnel'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'connectivity-matrix', 'underlay', 'tunnels', 'tunnel']
+
+ def _get_tunnel_name(self):
+ """
+ Getter method for tunnel_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/tunnel_name (string)
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ return self.__tunnel_name
+
+ def _set_tunnel_name(self, v, load=False):
+ """
+ Setter method for tunnel_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/tunnel_name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_name() directly.
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__tunnel_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_name(self):
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+ tunnel_name = __builtin__.property(_get_tunnel_name, _set_tunnel_name)
+ sharing = __builtin__.property(_get_sharing, _set_sharing)
+
+
+ _pyangbind_elements = OrderedDict([('tunnel_name', tunnel_name), ('sharing', sharing), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5a9838d5e9285068a7290d0398b8b73f3368bf7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restriction
+class label_restrictions(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The label restrictions container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__label_restriction',)
+
+ _yang_name = 'label-restrictions'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions']
+
+ def _get_label_restriction(self):
+ """
+ Getter method for label_restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction (list)
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ return self.__label_restriction
+
+ def _set_label_restriction(self, v, load=False):
+ """
+ Setter method for label_restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restriction() directly.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restriction must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__label_restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restriction(self):
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ label_restriction = __builtin__.property(_get_label_restriction, _set_label_restriction)
+
+
+ _pyangbind_elements = OrderedDict([('label_restriction', label_restriction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d5b189635af1cbfce81d2c8c81d0f6f3cd60e4e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/__init__.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_start
+from . import label_end
+from . import label_step
+from . import otn_label_range
+from . import ethernet_label_range
+class label_restriction(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restriction','__index','__label_start','__label_end','__label_step','__range_bitmap','__otn_label_range','__ethernet_label_range',)
+
+ _yang_name = 'label-restriction'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction']
+
+ def _get_restriction(self):
+ """
+ Getter method for restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/restriction (enumeration)
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ return self.__restriction
+
+ def _set_restriction(self, v, load=False):
+ """
+ Setter method for restriction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/restriction (enumeration)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restriction() directly.
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restriction must be of a type compatible with enumeration""",
+ 'defined-type': "ietf-te-topology:enumeration",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)""",
+ })
+
+ self.__restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restriction(self):
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/index (uint32)
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_label_start(self):
+ """
+ Getter method for label_start, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start (container)
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ return self.__label_start
+
+ def _set_label_start(self, v, load=False):
+ """
+ Setter method for label_start, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_start is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_start() directly.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_start must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_start = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_start(self):
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_end(self):
+ """
+ Getter method for label_end, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end (container)
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ return self.__label_end
+
+ def _set_label_end(self, v, load=False):
+ """
+ Setter method for label_end, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_end is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_end() directly.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_end must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_end = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_end(self):
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_step(self):
+ """
+ Getter method for label_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step (container)
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ return self.__label_step
+
+ def _set_label_step(self, v, load=False):
+ """
+ Setter method for label_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_step() directly.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_step must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_step(self):
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_range_bitmap(self):
+ """
+ Getter method for range_bitmap, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ return self.__range_bitmap
+
+ def _set_range_bitmap(self, v, load=False):
+ """
+ Setter method for range_bitmap, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_bitmap is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_bitmap() directly.
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_bitmap must be of a type compatible with yang:hex-string""",
+ 'defined-type': "yang:hex-string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)""",
+ })
+
+ self.__range_bitmap = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_bitmap(self):
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+
+
+ def _get_otn_label_range(self):
+ """
+ Getter method for otn_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range (container)
+
+ YANG Description: Label range information for OTN.
+ """
+ return self.__otn_label_range
+
+ def _set_otn_label_range(self, v, load=False):
+ """
+ Setter method for otn_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_label_range() directly.
+
+ YANG Description: Label range information for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_label_range(self):
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_ethernet_label_range(self):
+ """
+ Getter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range (container)
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ return self.__ethernet_label_range
+
+ def _set_ethernet_label_range(self, v, load=False):
+ """
+ Setter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ethernet_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ethernet_label_range() directly.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ethernet_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__ethernet_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ethernet_label_range(self):
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ restriction = __builtin__.property(_get_restriction, _set_restriction)
+ index = __builtin__.property(_get_index, _set_index)
+ label_start = __builtin__.property(_get_label_start, _set_label_start)
+ label_end = __builtin__.property(_get_label_end, _set_label_end)
+ label_step = __builtin__.property(_get_label_step, _set_label_step)
+ range_bitmap = __builtin__.property(_get_range_bitmap, _set_range_bitmap)
+ otn_label_range = __builtin__.property(_get_otn_label_range, _set_otn_label_range)
+ ethernet_label_range = __builtin__.property(_get_ethernet_label_range, _set_ethernet_label_range)
+
+
+ _pyangbind_elements = OrderedDict([('restriction', restriction), ('index', index), ('label_start', label_start), ('label_end', label_end), ('label_step', label_step), ('range_bitmap', range_bitmap), ('otn_label_range', otn_label_range), ('ethernet_label_range', ethernet_label_range), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1204389480fd9b8ed0595d7613aa8b414dbcb477
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ethernet_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction/ethernet-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tag_type','__priority',)
+
+ _yang_name = 'ethernet-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'ethernet-label-range']
+
+ def _get_tag_type(self):
+ """
+ Getter method for tag_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+
+ YANG Description: VLAN tag type.
+ """
+ return self.__tag_type
+
+ def _set_tag_type(self, v, load=False):
+ """
+ Setter method for tag_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tag_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tag_type() directly.
+
+ YANG Description: VLAN tag type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tag_type must be of a type compatible with etht-types:eth-tag-type""",
+ 'defined-type': "etht-types:eth-tag-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)""",
+ })
+
+ self.__tag_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tag_type(self):
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+
+ YANG Description: priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ tag_type = __builtin__.property(_get_tag_type, _set_tag_type)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('tag_type', tag_type), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9986d6a93f699df312ed09304fe1339944875650
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_end(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction/label-end. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-end'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-end']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..29e0c9a994b38322298dd936fd94a24595fdf972
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction/label-end/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-end', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1970e3999e8b9955bd6cf74faa612d1173617289
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction/label-end/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-end', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d88a176314ea898840f78842a2a4b508c80c989
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_start(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction/label-start. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-start'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-start']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..3a96742a0b76dff915d9b25a307f30e2893a0756
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction/label-start/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-start', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8dede38f39d25e5d7fb826718555365c2d8dc1ed
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction/label-start/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-start', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fefc31471c8537d744756122a1b6b4a58a58f7a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class label_step(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction/label-step. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_step',)
+
+ _yang_name = 'label-step'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-step']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/generic (int32)
+
+ YANG Description: Label range step.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/generic (int32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Label range step.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with int32""",
+ 'defined-type': "int32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/otn (container)
+
+ YANG Description: Label step for OTN
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label step for OTN
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_step(self):
+ """
+ Getter method for eth_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/eth_step (uint16)
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ return self.__eth_step
+
+ def _set_eth_step(self, v, load=False):
+ """
+ Setter method for eth_step, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/eth_step (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_step() directly.
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_step must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__eth_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_step(self):
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_step = __builtin__.property(_get_eth_step, _set_eth_step)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_step']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_step', eth_step), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a14b27f40324497c22ee722f9a4c17d2ecc72636
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction/label-step/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label step for OTN
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'label-step', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..734a4997ea378db0299b1a752f0ae69a5a5b7629
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/label-restrictions/label-restriction/otn-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label range information for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__range_type','__tsg','__odu_type_list','__priority',)
+
+ _yang_name = 'otn-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'label-restrictions', 'label-restriction', 'otn-label-range']
+
+ def _get_range_type(self):
+ """
+ Getter method for range_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ return self.__range_type
+
+ def _set_range_type(self, v, load=False):
+ """
+ Setter method for range_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_type() directly.
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_type must be of a type compatible with otn-label-range-type""",
+ 'defined-type': "ietf-otn-topology:otn-label-range-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)""",
+ })
+
+ self.__range_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_type(self):
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_odu_type_list(self):
+ """
+ Getter method for odu_type_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ return self.__odu_type_list
+
+ def _set_odu_type_list(self, v, load=False):
+ """
+ Setter method for odu_type_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type_list() directly.
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type_list must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type_list(self):
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ range_type = __builtin__.property(_get_range_type, _set_range_type)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ odu_type_list = __builtin__.property(_get_odu_type_list, _set_odu_type_list)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('range_type', range_type), ('tsg', tsg), ('odu_type_list', odu_type_list), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a38eef90a72f1cdd092ccb8fe5901fee29defdbb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/__init__.py
@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import optimization_metric
+from . import tiebreakers
+from . import objective_function
+class optimizations(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__optimization_metric','__tiebreakers','__objective_function',)
+
+ _yang_name = 'optimizations'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations']
+
+ def _get_optimization_metric(self):
+ """
+ Getter method for optimization_metric, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__optimization_metric
+
+ def _set_optimization_metric(self, v, load=False):
+ """
+ Setter method for optimization_metric, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimization_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimization_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimization_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__optimization_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimization_metric(self):
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+
+ def _get_tiebreakers(self):
+ """
+ Getter method for tiebreakers, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers (container)
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ return self.__tiebreakers
+
+ def _set_tiebreakers(self, v, load=False):
+ """
+ Setter method for tiebreakers, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreakers is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreakers() directly.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreakers must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tiebreakers = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreakers(self):
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_objective_function(self):
+ """
+ Getter method for objective_function, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/objective_function (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__objective_function
+
+ def _set_objective_function(self, v, load=False):
+ """
+ Setter method for objective_function, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/objective_function (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__objective_function = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function(self):
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ optimization_metric = __builtin__.property(_get_optimization_metric, _set_optimization_metric)
+ tiebreakers = __builtin__.property(_get_tiebreakers, _set_tiebreakers)
+ objective_function = __builtin__.property(_get_objective_function, _set_objective_function)
+
+ __choices__ = {'algorithm': {'metric': ['optimization_metric', 'tiebreakers'], 'objective-function': ['objective_function']}}
+ _pyangbind_elements = OrderedDict([('optimization_metric', optimization_metric), ('tiebreakers', tiebreakers), ('objective_function', objective_function), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/objective_function/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/objective_function/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3938cadf90bfcb85ebc6fd1c1651aed0364cd241
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/objective_function/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class objective_function(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/objective-function. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__objective_function_type',)
+
+ _yang_name = 'objective-function'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'objective-function']
+
+ def _get_objective_function_type(self):
+ """
+ Getter method for objective_function_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/objective_function/objective_function_type (identityref)
+
+ YANG Description: Objective function entry.
+ """
+ return self.__objective_function_type
+
+ def _set_objective_function_type(self, v, load=False):
+ """
+ Setter method for objective_function_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/objective_function/objective_function_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function_type() directly.
+
+ YANG Description: Objective function entry.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__objective_function_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function_type(self):
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ objective_function_type = __builtin__.property(_get_objective_function_type, _set_objective_function_type)
+
+ __choices__ = {'algorithm': {'objective-function': ['objective_function_type']}}
+ _pyangbind_elements = OrderedDict([('objective_function_type', objective_function_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8594a8e95b12f520dd13bb4dfc882f89e926768e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/__init__.py
@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import explicit_route_exclude_objects
+from . import explicit_route_include_objects
+class optimization_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__weight','__explicit_route_exclude_objects','__explicit_route_include_objects',)
+
+ _yang_name = 'optimization-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/metric_type (identityref)
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_weight(self):
+ """
+ Getter method for weight, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/weight (uint8)
+
+ YANG Description: TE path metric normalization weight.
+ """
+ return self.__weight
+
+ def _set_weight(self, v, load=False):
+ """
+ Setter method for weight, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/weight (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_weight is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_weight() directly.
+
+ YANG Description: TE path metric normalization weight.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """weight must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__weight = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_weight(self):
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_explicit_route_exclude_objects(self):
+ """
+ Getter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ return self.__explicit_route_exclude_objects
+
+ def _set_explicit_route_exclude_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_exclude_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_exclude_objects() directly.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_exclude_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__explicit_route_exclude_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_exclude_objects(self):
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_explicit_route_include_objects(self):
+ """
+ Getter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects (container)
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ return self.__explicit_route_include_objects
+
+ def _set_explicit_route_include_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_include_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_include_objects() directly.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_include_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__explicit_route_include_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_include_objects(self):
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ metric_type = __builtin__.property(_get_metric_type, _set_metric_type)
+ weight = __builtin__.property(_get_weight, _set_weight)
+ explicit_route_exclude_objects = __builtin__.property(_get_explicit_route_exclude_objects, _set_explicit_route_exclude_objects)
+ explicit_route_include_objects = __builtin__.property(_get_explicit_route_include_objects, _set_explicit_route_include_objects)
+
+ __choices__ = {'algorithm': {'metric': ['metric_type', 'weight', 'explicit_route_exclude_objects', 'explicit_route_include_objects']}}
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('weight', weight), ('explicit_route_exclude_objects', explicit_route_exclude_objects), ('explicit_route_include_objects', explicit_route_include_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d96148db39dd2d186fd6dc788b34c110a4e4c524
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_exclude_object
+class explicit_route_exclude_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_exclude_object',)
+
+ _yang_name = 'explicit-route-exclude-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects']
+
+ def _get_route_object_exclude_object(self):
+ """
+ Getter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ return self.__route_object_exclude_object
+
+ def _set_route_object_exclude_object(self, v, load=False):
+ """
+ Setter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_exclude_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_exclude_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_exclude_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__route_object_exclude_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_exclude_object(self):
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ route_object_exclude_object = __builtin__.property(_get_route_object_exclude_object, _set_route_object_exclude_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_exclude_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_exclude_object', route_object_exclude_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..be837bdc1d2e747ad69d14824dfb5c1abf483f4e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
@@ -0,0 +1,365 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+from . import srlg
+class route_object_exclude_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop','__srlg',)
+
+ _yang_name = 'route-object-exclude-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+
+ YANG Description: SRLG container.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+ srlg = __builtin__.property(_get_srlg, _set_srlg)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop'], 'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e6791351c451cf6b616a6679f1b75616327f0ae
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..50003dc6a7a4578fb95ad05dc949bd0098717f06
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b80329a9fed7d51e39a75e8efb2c70b4714c1a4b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..56737e8651ab92ae342efbf5c1b5bd19ebe87edb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c91d34b8b218b01e3c1dbf79f89352fa397954f8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9805bcdfcb99c69548e620d2afb8f12c9bfed42
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5c2961e6aba86a24fa1b7dab66f33b7193d69fc
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py
@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class srlg(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/srlg. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: SRLG container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__srlg',)
+
+ _yang_name = 'srlg'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__srlg = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'srlg']
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/srlg (uint32)
+
+ YANG Description: SRLG value.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/srlg (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+ srlg = __builtin__.property(_get_srlg, _set_srlg)
+
+ __choices__ = {'type': {'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a5b91f1ccf54c41b173d5eab05969a1d9e2be2f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..52d91329d11ca70cbaf141c5ee112fc3cc8437e1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_include_object
+class explicit_route_include_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_include_object',)
+
+ _yang_name = 'explicit-route-include-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_include_object = YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects']
+
+ def _get_route_object_include_object(self):
+ """
+ Getter method for route_object_include_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object (list)
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ return self.__route_object_include_object
+
+ def _set_route_object_include_object(self, v, load=False):
+ """
+ Setter method for route_object_include_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_include_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_include_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_include_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__route_object_include_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_include_object(self):
+ self.__route_object_include_object = YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ route_object_include_object = __builtin__.property(_get_route_object_include_object, _set_route_object_include_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_include_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_include_object', route_object_include_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b596318d6e06716db97ec964b066120ea2dda0d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py
@@ -0,0 +1,325 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class route_object_include_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'route-object-include-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..005900b6dedd25bd5cd711a0945e0c9a9755fa66
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cec600652c93867f4ddc94bda61ee53ede563677
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5212e8f5d6939f4929845a9486e70c673c1ffa2b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..de434357d1096ad61bc755d75a724f06cc38005d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4d2fdce18c44d1eb2b425de0a8e33f5b60bffd7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5f6b873cc2a9134a97adf32b75375df3dc8a1d4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3cc0d8dec78461878afe20fb2f0c17d96747a9b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1132534b5ff8e33c85f6856b303b5eb96f851eab
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tiebreaker
+class tiebreakers(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/tiebreakers. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tiebreaker',)
+
+ _yang_name = 'tiebreakers'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tiebreaker = YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'tiebreakers']
+
+ def _get_tiebreaker(self):
+ """
+ Getter method for tiebreaker, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers/tiebreaker (list)
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ return self.__tiebreaker
+
+ def _set_tiebreaker(self, v, load=False):
+ """
+ Setter method for tiebreaker, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers/tiebreaker (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreaker is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreaker() directly.
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreaker must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__tiebreaker = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreaker(self):
+ self.__tiebreaker = YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ tiebreaker = __builtin__.property(_get_tiebreaker, _set_tiebreaker)
+
+ __choices__ = {'algorithm': {'metric': ['tiebreaker']}}
+ _pyangbind_elements = OrderedDict([('tiebreaker', tiebreaker), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers/tiebreaker/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers/tiebreaker/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..41f4df7a218348839dec615158e0d032b92abb30
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers/tiebreaker/__init__.py
@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tiebreaker(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/optimizations/tiebreakers/tiebreaker. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tiebreaker_type',)
+
+ _yang_name = 'tiebreaker'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tiebreaker_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'optimizations', 'tiebreakers', 'tiebreaker']
+
+ def _get_tiebreaker_type(self):
+ """
+ Getter method for tiebreaker_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers/tiebreaker/tiebreaker_type (identityref)
+
+ YANG Description: Identifies an entry in the list of tiebreakers.
+ """
+ return self.__tiebreaker_type
+
+ def _set_tiebreaker_type(self, v, load=False):
+ """
+ Setter method for tiebreaker_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/tiebreakers/tiebreaker/tiebreaker_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreaker_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreaker_type() directly.
+
+ YANG Description: Identifies an entry in the list of tiebreakers.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreaker_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tiebreaker_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreaker_type(self):
+ self.__tiebreaker_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ tiebreaker_type = __builtin__.property(_get_tiebreaker_type, _set_tiebreaker_type)
+
+ __choices__ = {'algorithm': {'metric': ['tiebreaker_type']}}
+ _pyangbind_elements = OrderedDict([('tiebreaker_type', tiebreaker_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8f93bf028e2a37fe3e5edb85b170f104117a751
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/__init__.py
@@ -0,0 +1,523 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+from . import path_metric_bounds
+from . import path_affinities_values
+from . import path_affinity_names
+from . import path_srlgs_lists
+from . import path_srlgs_names
+class path_constraints(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE named path constraints container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_bandwidth','__link_protection','__setup_priority','__hold_priority','__signaling_type','__path_metric_bounds','__path_affinities_values','__path_affinity_names','__path_srlgs_lists','__path_srlgs_names','__disjointness',)
+
+ _yang_name = 'path-constraints'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__link_protection = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__setup_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__hold_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__signaling_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__path_metric_bounds = YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__disjointness = YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints']
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_link_protection(self):
+ """
+ Getter method for link_protection, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/link_protection (identityref)
+
+ YANG Description: Link protection type required for the links included
+in the computed path.
+ """
+ return self.__link_protection
+
+ def _set_link_protection(self, v, load=False):
+ """
+ Setter method for link_protection, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/link_protection (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_protection is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_protection() directly.
+
+ YANG Description: Link protection type required for the links included
+in the computed path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_protection must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__link_protection = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_protection(self):
+ self.__link_protection = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_setup_priority(self):
+ """
+ Getter method for setup_priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/setup_priority (uint8)
+
+ YANG Description: TE LSP requested setup priority.
+ """
+ return self.__setup_priority
+
+ def _set_setup_priority(self, v, load=False):
+ """
+ Setter method for setup_priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/setup_priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_setup_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_setup_priority() directly.
+
+ YANG Description: TE LSP requested setup priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """setup_priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__setup_priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_setup_priority(self):
+ self.__setup_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_hold_priority(self):
+ """
+ Getter method for hold_priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/hold_priority (uint8)
+
+ YANG Description: TE LSP requested hold priority.
+ """
+ return self.__hold_priority
+
+ def _set_hold_priority(self, v, load=False):
+ """
+ Setter method for hold_priority, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/hold_priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hold_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hold_priority() directly.
+
+ YANG Description: TE LSP requested hold priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hold_priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__hold_priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hold_priority(self):
+ self.__hold_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_signaling_type(self):
+ """
+ Getter method for signaling_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/signaling_type (identityref)
+
+ YANG Description: TE tunnel path signaling type.
+ """
+ return self.__signaling_type
+
+ def _set_signaling_type(self, v, load=False):
+ """
+ Setter method for signaling_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/signaling_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_signaling_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_signaling_type() directly.
+
+ YANG Description: TE tunnel path signaling type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """signaling_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__signaling_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_signaling_type(self):
+ self.__signaling_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_path_metric_bounds(self):
+ """
+ Getter method for path_metric_bounds, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds (container)
+
+ YANG Description: TE path metric bounds container.
+ """
+ return self.__path_metric_bounds
+
+ def _set_path_metric_bounds(self, v, load=False):
+ """
+ Setter method for path_metric_bounds, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric_bounds is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric_bounds() directly.
+
+ YANG Description: TE path metric bounds container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric_bounds must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_metric_bounds = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric_bounds(self):
+ self.__path_metric_bounds = YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_affinities_values(self):
+ """
+ Getter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values (container)
+
+ YANG Description: Path affinities represented as values.
+ """
+ return self.__path_affinities_values
+
+ def _set_path_affinities_values(self, v, load=False):
+ """
+ Setter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_values() directly.
+
+ YANG Description: Path affinities represented as values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_values must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_affinities_values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_values(self):
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_affinity_names(self):
+ """
+ Getter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names (container)
+
+ YANG Description: Path affinities represented as names.
+ """
+ return self.__path_affinity_names
+
+ def _set_path_affinity_names(self, v, load=False):
+ """
+ Setter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_names() directly.
+
+ YANG Description: Path affinities represented as names.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_affinity_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_names(self):
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_srlgs_lists(self):
+ """
+ Getter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists (container)
+
+ YANG Description: Path SRLG properties container.
+ """
+ return self.__path_srlgs_lists
+
+ def _set_path_srlgs_lists(self, v, load=False):
+ """
+ Setter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_lists is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_lists() directly.
+
+ YANG Description: Path SRLG properties container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_lists must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_srlgs_lists = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_lists(self):
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_srlgs_names(self):
+ """
+ Getter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names (container)
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ return self.__path_srlgs_names
+
+ def _set_path_srlgs_names(self, v, load=False):
+ """
+ Setter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_names() directly.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_srlgs_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_names(self):
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_disjointness(self):
+ """
+ Getter method for disjointness, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/disjointness (te-path-disjointness)
+
+ YANG Description: The type of resource disjointness.
+When configured for a primary path, the disjointness level
+applies to all secondary LSPs. When configured for a
+secondary path, the disjointness level overrides the level
+configured for the primary path.
+ """
+ return self.__disjointness
+
+ def _set_disjointness(self, v, load=False):
+ """
+ Setter method for disjointness, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/disjointness (te-path-disjointness)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_disjointness is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_disjointness() directly.
+
+ YANG Description: The type of resource disjointness.
+When configured for a primary path, the disjointness level
+applies to all secondary LSPs. When configured for a
+secondary path, the disjointness level overrides the level
+configured for the primary path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """disjointness must be of a type compatible with te-path-disjointness""",
+ 'defined-type': "ietf-te-topology:te-path-disjointness",
+ 'generated-type': """YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)""",
+ })
+
+ self.__disjointness = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_disjointness(self):
+ self.__disjointness = YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)
+
+ te_bandwidth = __builtin__.property(_get_te_bandwidth, _set_te_bandwidth)
+ link_protection = __builtin__.property(_get_link_protection, _set_link_protection)
+ setup_priority = __builtin__.property(_get_setup_priority, _set_setup_priority)
+ hold_priority = __builtin__.property(_get_hold_priority, _set_hold_priority)
+ signaling_type = __builtin__.property(_get_signaling_type, _set_signaling_type)
+ path_metric_bounds = __builtin__.property(_get_path_metric_bounds, _set_path_metric_bounds)
+ path_affinities_values = __builtin__.property(_get_path_affinities_values, _set_path_affinities_values)
+ path_affinity_names = __builtin__.property(_get_path_affinity_names, _set_path_affinity_names)
+ path_srlgs_lists = __builtin__.property(_get_path_srlgs_lists, _set_path_srlgs_lists)
+ path_srlgs_names = __builtin__.property(_get_path_srlgs_names, _set_path_srlgs_names)
+ disjointness = __builtin__.property(_get_disjointness, _set_disjointness)
+
+
+ _pyangbind_elements = OrderedDict([('te_bandwidth', te_bandwidth), ('link_protection', link_protection), ('setup_priority', setup_priority), ('hold_priority', hold_priority), ('signaling_type', signaling_type), ('path_metric_bounds', path_metric_bounds), ('path_affinities_values', path_affinities_values), ('path_affinity_names', path_affinity_names), ('path_srlgs_lists', path_srlgs_lists), ('path_srlgs_names', path_srlgs_names), ('disjointness', disjointness), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b04586e5a02caa02cdba4ade49800cd965d3ef7e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinities_value
+class path_affinities_values(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-affinities-values. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as values.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinities_value',)
+
+ _yang_name = 'path-affinities-values'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-affinities-values']
+
+ def _get_path_affinities_value(self):
+ """
+ Getter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinities_value
+
+ def _set_path_affinities_value(self, v, load=False):
+ """
+ Setter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_value() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_value must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_affinities_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_value(self):
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_affinities_value = __builtin__.property(_get_path_affinities_value, _set_path_affinities_value)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinities_value', path_affinities_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..d4347e12ea53c9cefb7bccada9082f10a464b6b0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_affinities_value(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-affinities-values/path-affinities-value. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__value',)
+
+ _yang_name = 'path-affinities-value'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-affinities-values', 'path-affinities-value']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/value (admin-groups)
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/value (admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with admin-groups""",
+ 'defined-type': "ietf-te-topology:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ value = __builtin__.property(_get_value, _set_value)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9511703bf8e9694635ac3c13504148fb1ad95b6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinity_name
+class path_affinity_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-affinity-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as names.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinity_name',)
+
+ _yang_name = 'path-affinity-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-affinity-names']
+
+ def _get_path_affinity_name(self):
+ """
+ Getter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinity_name
+
+ def _set_path_affinity_name(self, v, load=False):
+ """
+ Setter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_name() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_name(self):
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_affinity_name = __builtin__.property(_get_path_affinity_name, _set_path_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinity_name', path_affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..5bea16d3c52a67c620abb434d7df593984786f32
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/__init__.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import affinity_name
+class path_affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-affinity-names/path-affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__affinity_name',)
+
+ _yang_name = 'path-affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-affinity-names', 'path-affinity-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_affinity_name(self):
+ """
+ Getter method for affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name (list)
+
+ YANG Description: List of named affinities.
+ """
+ return self.__affinity_name
+
+ def _set_affinity_name(self, v, load=False):
+ """
+ Setter method for affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_affinity_name() directly.
+
+ YANG Description: List of named affinities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_affinity_name(self):
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ affinity_name = __builtin__.property(_get_affinity_name, _set_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('affinity_name', affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..27b87f524fe2cdfe1696f7320ede4b3f1e92cb83
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-affinity-names/path-affinity-name/affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__name',)
+
+ _yang_name = 'affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-affinity-names', 'path-affinity-name', 'affinity-name']
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/name (string)
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ name = __builtin__.property(_get_name, _set_name)
+
+
+ _pyangbind_elements = OrderedDict([('name', name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..89e9dcde547360b821a9c8c5ee4660edbc4b6c5d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_metric_bound
+class path_metric_bounds(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-metric-bounds. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric bounds container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_metric_bound',)
+
+ _yang_name = 'path-metric-bounds'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_metric_bound = YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-metric-bounds']
+
+ def _get_path_metric_bound(self):
+ """
+ Getter method for path_metric_bound, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound (list)
+
+ YANG Description: List of TE path metric bounds.
+ """
+ return self.__path_metric_bound
+
+ def _set_path_metric_bound(self, v, load=False):
+ """
+ Setter method for path_metric_bound, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric_bound is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric_bound() directly.
+
+ YANG Description: List of TE path metric bounds.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric_bound must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_metric_bound = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric_bound(self):
+ self.__path_metric_bound = YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_metric_bound = __builtin__.property(_get_path_metric_bound, _set_path_metric_bound)
+
+
+ _pyangbind_elements = OrderedDict([('path_metric_bound', path_metric_bound), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..9e967408a9a763bc5ade1f35fb1b05d53a24dcdd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/__init__.py
@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_metric_bound(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-metric-bounds/path-metric-bound. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of TE path metric bounds.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__upper_bound',)
+
+ _yang_name = 'path-metric-bound'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__upper_bound = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-metric-bounds', 'path-metric-bound']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/metric_type (identityref)
+
+ YANG Description: Identifies an entry in the list of 'metric-type' items
+bound for the TE path.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies an entry in the list of 'metric-type' items
+bound for the TE path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_upper_bound(self):
+ """
+ Getter method for upper_bound, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/upper_bound (uint64)
+
+ YANG Description: Upper bound on the end-to-end TE path metric. A zero
+indicates an unbounded upper limit for the specific
+'metric-type'.
+ """
+ return self.__upper_bound
+
+ def _set_upper_bound(self, v, load=False):
+ """
+ Setter method for upper_bound, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/upper_bound (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_upper_bound is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_upper_bound() directly.
+
+ YANG Description: Upper bound on the end-to-end TE path metric. A zero
+indicates an unbounded upper limit for the specific
+'metric-type'.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """upper_bound must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__upper_bound = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_upper_bound(self):
+ self.__upper_bound = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+
+ metric_type = __builtin__.property(_get_metric_type, _set_metric_type)
+ upper_bound = __builtin__.property(_get_upper_bound, _set_upper_bound)
+
+
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('upper_bound', upper_bound), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a3633c2824838a95ae720bd56f086266676db6c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_list
+class path_srlgs_lists(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-srlgs-lists. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path SRLG properties container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_list',)
+
+ _yang_name = 'path-srlgs-lists'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-srlgs-lists']
+
+ def _get_path_srlgs_list(self):
+ """
+ Getter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list (list)
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ return self.__path_srlgs_list
+
+ def _set_path_srlgs_list(self, v, load=False):
+ """
+ Setter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_list() directly.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_list must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_srlgs_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_list(self):
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_srlgs_list = __builtin__.property(_get_path_srlgs_list, _set_path_srlgs_list)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_list', path_srlgs_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..25eecfaa4a3db913d594884ad74d7f7eecb8a36e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_list(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-srlgs-lists/path-srlgs-list. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__values',)
+
+ _yang_name = 'path-srlgs-list'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-srlgs-lists', 'path-srlgs-list']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_values(self):
+ """
+ Getter method for values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/values (srlg)
+
+ YANG Description: List of SRLG values.
+ """
+ return self.__values
+
+ def _set_values(self, v, load=False):
+ """
+ Setter method for values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/values (srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_values() directly.
+
+ YANG Description: List of SRLG values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """values must be of a type compatible with srlg""",
+ 'defined-type': "ietf-te-topology:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)""",
+ })
+
+ self.__values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_values(self):
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ values = __builtin__.property(_get_values, _set_values)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('values', values), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d26858176b971d3c4f3239a8d8bc6292ee672870
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_name
+class path_srlgs_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-srlgs-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_name',)
+
+ _yang_name = 'path-srlgs-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-srlgs-names']
+
+ def _get_path_srlgs_name(self):
+ """
+ Getter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name (list)
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ return self.__path_srlgs_name
+
+ def _set_path_srlgs_name(self, v, load=False):
+ """
+ Setter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_name() directly.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_srlgs_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_name(self):
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_srlgs_name = __builtin__.property(_get_path_srlgs_name, _set_path_srlgs_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_name', path_srlgs_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..305a401ae4c6bb90679de7e8a1624af89343e824
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/path-srlgs-names/path-srlgs-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__names',)
+
+ _yang_name = 'path-srlgs-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'path-srlgs-names', 'path-srlgs-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_names(self):
+ """
+ Getter method for names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/names (string)
+
+ YANG Description: List of named SRLGs.
+ """
+ return self.__names
+
+ def _set_names(self, v, load=False):
+ """
+ Setter method for names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/names (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_names() directly.
+
+ YANG Description: List of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """names must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_names(self):
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ names = __builtin__.property(_get_names, _set_names)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('names', names), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..040c69e2f13a047ab67829c3afbc07d100255f40
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth, _set_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_bandwidth']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1d6ad9171b4add999a0140df250cb751b300b15
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/__init__.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist','__odtu_flex_type',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+
+
+ def _get_odtu_flex_type(self):
+ """
+ Getter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+set up along the underlay paths of these OTN
+connectivity matrices.
+ """
+ return self.__odtu_flex_type
+
+ def _set_odtu_flex_type(self, v, load=False):
+ """
+ Setter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odtu_flex_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odtu_flex_type() directly.
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+set up along the underlay paths of these OTN
+connectivity matrices.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odtu_flex_type must be of a type compatible with l1-types:odtu-flex-type""",
+ 'defined-type': "l1-types:odtu-flex-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)""",
+ })
+
+ self.__odtu_flex_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odtu_flex_type(self):
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+
+ odulist = __builtin__.property(_get_odulist, _set_odulist)
+ odtu_flex_type = __builtin__.property(_get_odtu_flex_type, _set_odtu_flex_type)
+
+ __choices__ = {'technology': {'otn': ['odulist', 'odtu_flex_type']}}
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ('odtu_flex_type', odtu_flex_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6577089cc08d9214b7aca30ef8bcf76ce08397f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-constraints/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-constraints', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ odu_type = __builtin__.property(_get_odu_type, _set_odu_type)
+ number = __builtin__.property(_get_number, _set_number)
+ ts_number = __builtin__.property(_get_ts_number, _set_ts_number)
+
+ __choices__ = {'technology': {'otn': ['odu_type', 'number', 'ts_number']}}
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5633ecb2d25084b568dd17769a8890bb2ca9039c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/__init__.py
@@ -0,0 +1,318 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_metric
+from . import path_affinities_values
+from . import path_affinity_names
+from . import path_srlgs_lists
+from . import path_srlgs_names
+from . import path_route_objects
+class path_properties(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The TE path properties.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_metric','__path_affinities_values','__path_affinity_names','__path_srlgs_lists','__path_srlgs_names','__path_route_objects',)
+
+ _yang_name = 'path-properties'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_metric = YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_route_objects = YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties']
+
+ def _get_path_metric(self):
+ """
+ Getter method for path_metric, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__path_metric
+
+ def _set_path_metric(self, v, load=False):
+ """
+ Setter method for path_metric, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric(self):
+ self.__path_metric = YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_path_affinities_values(self):
+ """
+ Getter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values (container)
+
+ YANG Description: Path affinities represented as values.
+ """
+ return self.__path_affinities_values
+
+ def _set_path_affinities_values(self, v, load=False):
+ """
+ Setter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_values() directly.
+
+ YANG Description: Path affinities represented as values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_values must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinities_values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_values(self):
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_affinity_names(self):
+ """
+ Getter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names (container)
+
+ YANG Description: Path affinities represented as names.
+ """
+ return self.__path_affinity_names
+
+ def _set_path_affinity_names(self, v, load=False):
+ """
+ Setter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_names() directly.
+
+ YANG Description: Path affinities represented as names.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinity_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_names(self):
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_lists(self):
+ """
+ Getter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists (container)
+
+ YANG Description: Path SRLG properties container.
+ """
+ return self.__path_srlgs_lists
+
+ def _set_path_srlgs_lists(self, v, load=False):
+ """
+ Setter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_lists is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_lists() directly.
+
+ YANG Description: Path SRLG properties container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_lists must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_lists = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_lists(self):
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_names(self):
+ """
+ Getter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names (container)
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ return self.__path_srlgs_names
+
+ def _set_path_srlgs_names(self, v, load=False):
+ """
+ Setter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_names() directly.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_names(self):
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_route_objects(self):
+ """
+ Getter method for path_route_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects (container)
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ return self.__path_route_objects
+
+ def _set_path_route_objects(self, v, load=False):
+ """
+ Setter method for path_route_objects, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_route_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_route_objects() directly.
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_route_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_route_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_route_objects(self):
+ self.__path_route_objects = YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ path_metric = __builtin__.property(_get_path_metric)
+ path_affinities_values = __builtin__.property(_get_path_affinities_values)
+ path_affinity_names = __builtin__.property(_get_path_affinity_names)
+ path_srlgs_lists = __builtin__.property(_get_path_srlgs_lists)
+ path_srlgs_names = __builtin__.property(_get_path_srlgs_names)
+ path_route_objects = __builtin__.property(_get_path_route_objects)
+
+
+ _pyangbind_elements = OrderedDict([('path_metric', path_metric), ('path_affinities_values', path_affinities_values), ('path_affinity_names', path_affinity_names), ('path_srlgs_lists', path_srlgs_lists), ('path_srlgs_names', path_srlgs_names), ('path_route_objects', path_route_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..49d1090f243669947bbd030100ad5b132480bce7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinities_value
+class path_affinities_values(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-affinities-values. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as values.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinities_value',)
+
+ _yang_name = 'path-affinities-values'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-affinities-values']
+
+ def _get_path_affinities_value(self):
+ """
+ Getter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinities_value
+
+ def _set_path_affinities_value(self, v, load=False):
+ """
+ Setter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_value() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_value must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinities_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_value(self):
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinities_value = __builtin__.property(_get_path_affinities_value)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinities_value', path_affinities_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..e387bf9bfbd3c4799f23211105a7a1a91c98c413
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_affinities_value(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-affinities-values/path-affinities-value. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__value',)
+
+ _yang_name = 'path-affinities-value'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-affinities-values', 'path-affinities-value']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/value (admin-groups)
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/value (admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with admin-groups""",
+ 'defined-type': "ietf-te-topology:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ value = __builtin__.property(_get_value)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..904de87a16de9e7c7870cf3ab2839ab7d7afdf53
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinity_name
+class path_affinity_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-affinity-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as names.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinity_name',)
+
+ _yang_name = 'path-affinity-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-affinity-names']
+
+ def _get_path_affinity_name(self):
+ """
+ Getter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinity_name
+
+ def _set_path_affinity_name(self, v, load=False):
+ """
+ Setter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_name() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_name(self):
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinity_name = __builtin__.property(_get_path_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinity_name', path_affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..c7b9e5faf5d46d9e7ea2f444562672d7b75f9a8c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/__init__.py
@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import affinity_name
+class path_affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-affinity-names/path-affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__affinity_name',)
+
+ _yang_name = 'path-affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-affinity-names', 'path-affinity-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_affinity_name(self):
+ """
+ Getter method for affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name (list)
+
+ YANG Description: List of named affinities.
+ """
+ return self.__affinity_name
+
+ def _set_affinity_name(self, v, load=False):
+ """
+ Setter method for affinity_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_affinity_name() directly.
+
+ YANG Description: List of named affinities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_affinity_name(self):
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ affinity_name = __builtin__.property(_get_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('affinity_name', affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..8e41672e8151473007d724a85f7b4dde8e5f20c2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-affinity-names/path-affinity-name/affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__name',)
+
+ _yang_name = 'affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-affinity-names', 'path-affinity-name', 'affinity-name']
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/name (string)
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ name = __builtin__.property(_get_name)
+
+
+ _pyangbind_elements = OrderedDict([('name', name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a8fae1c4a91b30a5b08483906f57eb84c4f2772
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric/__init__.py
@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__accumulative_value',)
+
+ _yang_name = 'path-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__accumulative_value = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric/metric_type (identityref)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: TE path metric type.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_accumulative_value(self):
+ """
+ Getter method for accumulative_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric/accumulative_value (uint64)
+
+ YANG Description: TE path metric accumulative value.
+ """
+ return self.__accumulative_value
+
+ def _set_accumulative_value(self, v, load=False):
+ """
+ Setter method for accumulative_value, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric/accumulative_value (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_accumulative_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_accumulative_value() directly.
+
+ YANG Description: TE path metric accumulative value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """accumulative_value must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__accumulative_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_accumulative_value(self):
+ self.__accumulative_value = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ metric_type = __builtin__.property(_get_metric_type)
+ accumulative_value = __builtin__.property(_get_accumulative_value)
+
+
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('accumulative_value', accumulative_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f30f10e68c50711bfaee7aea0510143e4094481
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_route_object
+class path_route_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-route-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_route_object',)
+
+ _yang_name = 'path-route-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_route_object = YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-route-objects']
+
+ def _get_path_route_object(self):
+ """
+ Getter method for path_route_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object (list)
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ return self.__path_route_object
+
+ def _set_path_route_object(self, v, load=False):
+ """
+ Setter method for path_route_object, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_route_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_route_object() directly.
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_route_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_route_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_route_object(self):
+ self.__path_route_object = YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_route_object = __builtin__.property(_get_path_route_object)
+
+
+ _pyangbind_elements = OrderedDict([('path_route_object', path_route_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..9e85f737c57910db3b874a5d07f8cb45e3158977
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/__init__.py
@@ -0,0 +1,327 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_route_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-route-objects/path-route-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-route-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key
+values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key
+values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..14f8c67c4ef9c74d8fbd42a4e7a3e9a8c81b505e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-route-objects/path-route-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d816d11be71d3d6e12e7427275b7aba68ea7db7e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-route-objects/path-route-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b21aa6b8cd180833494e5203ff9cca2f713a49b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-route-objects/path-route-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f24877ab2ea24a1fb2b4e4f84e35c98c2639ee1b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-route-objects/path-route-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..266d0f1c07b92f372a1f032563aa9420a72467f4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-route-objects/path-route-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e2ef7ce2cf0584b95c92c54f010df7c6ef0b79d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-route-objects/path-route-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..70b149a486ea4182317a5cc63704beb895960b01
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-route-objects/path-route-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-route-objects', 'path-route-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6b374b8c1e0392f46c09b2b228c69ae59d5cb5f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_list
+class path_srlgs_lists(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-srlgs-lists. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path SRLG properties container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_list',)
+
+ _yang_name = 'path-srlgs-lists'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-srlgs-lists']
+
+ def _get_path_srlgs_list(self):
+ """
+ Getter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list (list)
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ return self.__path_srlgs_list
+
+ def _set_path_srlgs_list(self, v, load=False):
+ """
+ Setter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_list() directly.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_list must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_list(self):
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_list = __builtin__.property(_get_path_srlgs_list)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_list', path_srlgs_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..59e2a8be232fd3e7b825e5c8f77d34eecbd25490
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_list(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-srlgs-lists/path-srlgs-list. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__values',)
+
+ _yang_name = 'path-srlgs-list'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-srlgs-lists', 'path-srlgs-list']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_values(self):
+ """
+ Getter method for values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/values (srlg)
+
+ YANG Description: List of SRLG values.
+ """
+ return self.__values
+
+ def _set_values(self, v, load=False):
+ """
+ Setter method for values, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/values (srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_values() directly.
+
+ YANG Description: List of SRLG values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """values must be of a type compatible with srlg""",
+ 'defined-type': "ietf-te-topology:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)""",
+ })
+
+ self.__values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_values(self):
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ values = __builtin__.property(_get_values)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('values', values), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..10673844150c886a74e09133e59d07cd663f56eb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_name
+class path_srlgs_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-srlgs-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_name',)
+
+ _yang_name = 'path-srlgs-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-srlgs-names']
+
+ def _get_path_srlgs_name(self):
+ """
+ Getter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name (list)
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ return self.__path_srlgs_name
+
+ def _set_path_srlgs_name(self, v, load=False):
+ """
+ Setter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_name() directly.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_name(self):
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_name = __builtin__.property(_get_path_srlgs_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_name', path_srlgs_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..20a2aee2aaf4e0712a6c94a1ac22d09a164c253f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/__init__.py
@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/path-properties/path-srlgs-names/path-srlgs-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__names',)
+
+ _yang_name = 'path-srlgs-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'path-properties', 'path-srlgs-names', 'path-srlgs-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_names(self):
+ """
+ Getter method for names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/names (string)
+
+ YANG Description: List of named SRLGs.
+ """
+ return self.__names
+
+ def _set_names(self, v, load=False):
+ """
+ Setter method for names, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/names (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_names() directly.
+
+ YANG Description: List of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """names must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_names(self):
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ names = __builtin__.property(_get_names)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('names', names), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d1acaeb59c441fc4e85bd31e4b5c959646b4410
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/__init__.py
@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import primary_path
+from . import backup_path
+from . import tunnel_termination_points
+from . import tunnels
+class underlay(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__enabled','__primary_path','__backup_path','__protection_type','__tunnel_termination_points','__tunnels',)
+
+ _yang_name = 'underlay'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay']
+
+ def _get_enabled(self):
+ """
+ Getter method for enabled, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/enabled (boolean)
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ return self.__enabled
+
+ def _set_enabled(self, v, load=False):
+ """
+ Setter method for enabled, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/enabled (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_enabled is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_enabled() directly.
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """enabled must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__enabled = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_enabled(self):
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_primary_path(self):
+ """
+ Getter method for primary_path, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path (container)
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ return self.__primary_path
+
+ def _set_primary_path(self, v, load=False):
+ """
+ Setter method for primary_path, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_primary_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_primary_path() directly.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """primary_path must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__primary_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_primary_path(self):
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_backup_path(self):
+ """
+ Getter method for backup_path, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path (list)
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ return self.__backup_path
+
+ def _set_backup_path(self, v, load=False):
+ """
+ Setter method for backup_path, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_backup_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_backup_path() directly.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """backup_path must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__backup_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_backup_path(self):
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+
+ def _get_protection_type(self):
+ """
+ Getter method for protection_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/protection_type (identityref)
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ return self.__protection_type
+
+ def _set_protection_type(self, v, load=False):
+ """
+ Setter method for protection_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/protection_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_protection_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_protection_type() directly.
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """protection_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__protection_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_protection_type(self):
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_tunnel_termination_points(self):
+ """
+ Getter method for tunnel_termination_points, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points (container)
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ return self.__tunnel_termination_points
+
+ def _set_tunnel_termination_points(self, v, load=False):
+ """
+ Setter method for tunnel_termination_points, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_termination_points is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_termination_points() directly.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_termination_points must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tunnel_termination_points = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_termination_points(self):
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_tunnels(self):
+ """
+ Getter method for tunnels, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels (container)
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ return self.__tunnels
+
+ def _set_tunnels(self, v, load=False):
+ """
+ Setter method for tunnels, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnels is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnels() directly.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnels must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tunnels = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnels(self):
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ enabled = __builtin__.property(_get_enabled, _set_enabled)
+ primary_path = __builtin__.property(_get_primary_path, _set_primary_path)
+ backup_path = __builtin__.property(_get_backup_path, _set_backup_path)
+ protection_type = __builtin__.property(_get_protection_type, _set_protection_type)
+ tunnel_termination_points = __builtin__.property(_get_tunnel_termination_points, _set_tunnel_termination_points)
+ tunnels = __builtin__.property(_get_tunnels, _set_tunnels)
+
+
+ _pyangbind_elements = OrderedDict([('enabled', enabled), ('primary_path', primary_path), ('backup_path', backup_path), ('protection_type', protection_type), ('tunnel_termination_points', tunnel_termination_points), ('tunnels', tunnels), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6dae020814684bdfb0b995cd3112c73fbf7a82e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/__init__.py
@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class backup_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/backup-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__network_ref','__path_element',)
+
+ _yang_name = 'backup-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'backup-path']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/index (uint32)
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element (list)
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ path_element = __builtin__.property(_get_path_element, _set_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('index', index), ('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..32f0ddafba5db1546c8ad50177a73780a0b1b5fa
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/__init__.py
@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/backup-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ path_element_id = __builtin__.property(_get_path_element_id, _set_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3522a13e96033c1b2936edb56798e8b8c6ecca67
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/backup-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce150a6055725d0d19578db2459899d1890731d3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/backup-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef37b6389233bdb4c07a827476bbe779dc4a3dd1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/backup-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..64da0e1fd7327284ece6dd1baf8cb7e64314a0d4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/backup-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b441de5c590d046d6c55cff535467fe302fc150
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/backup-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a2ff93d585b79da9c7a5a8a5633e1bca804d347
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/backup-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f686b596028c476f635af54e3db27df9fd88d30
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/backup-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'backup-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c75b0b21600a332b60b58712fdde9934b9547e11
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class primary_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/primary-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref','__path_element',)
+
+ _yang_name = 'primary-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'primary-path']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element (list)
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ path_element = __builtin__.property(_get_path_element, _set_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9c1a617001c158d8c9a6f74f7a0414356e9e111
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/__init__.py
@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/primary-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ path_element_id = __builtin__.property(_get_path_element_id, _set_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c3bb0005ff1dc2926197c1af5e242f04e9aee10
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/primary-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc6a1621914ea32479aea31f5db5d3aebc0e8e98
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/primary-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1db2ca234326d8bd3577ea24c539864ec672152
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/primary-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b291e326c2abd344565772273324e7ffb082704
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/primary-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccb0ca471771b6c5cc6cb3e85796e099f0062e34
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/primary-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c0fdf8daf0e9db2468488e52b54a4a7d1871da7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/primary-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c70dd4cc0245ca118568b9d3905fddf50f8ee453
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/primary-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'primary-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..01b0c397670aad0d2c9ac7a892ab83fa1a979da7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel_termination_points(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/tunnel-termination-points. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__source','__destination',)
+
+ _yang_name = 'tunnel-termination-points'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'tunnel-termination-points']
+
+ def _get_source(self):
+ """
+ Getter method for source, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points/source (binary)
+
+ YANG Description: Source TTP identifier.
+ """
+ return self.__source
+
+ def _set_source(self, v, load=False):
+ """
+ Setter method for source, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points/source (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_source() directly.
+
+ YANG Description: Source TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """source must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)""",
+ })
+
+ self.__source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_source(self):
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+
+ def _get_destination(self):
+ """
+ Getter method for destination, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points/destination (binary)
+
+ YANG Description: Destination TTP identifier.
+ """
+ return self.__destination
+
+ def _set_destination(self, v, load=False):
+ """
+ Setter method for destination, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points/destination (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_destination is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_destination() directly.
+
+ YANG Description: Destination TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """destination must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)""",
+ })
+
+ self.__destination = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_destination(self):
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+ source = __builtin__.property(_get_source, _set_source)
+ destination = __builtin__.property(_get_destination, _set_destination)
+
+
+ _pyangbind_elements = OrderedDict([('source', source), ('destination', destination), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8b792d49d202131fb439164a8c15614e350976d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/__init__.py
@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tunnel
+class tunnels(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/tunnels. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__sharing','__tunnel',)
+
+ _yang_name = 'tunnels'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'tunnels']
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_tunnel(self):
+ """
+ Getter method for tunnel, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel (list)
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ return self.__tunnel
+
+ def _set_tunnel(self, v, load=False):
+ """
+ Setter method for tunnel, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel() directly.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__tunnel = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel(self):
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ sharing = __builtin__.property(_get_sharing, _set_sharing)
+ tunnel = __builtin__.property(_get_tunnel, _set_tunnel)
+
+
+ _pyangbind_elements = OrderedDict([('sharing', sharing), ('tunnel', tunnel), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..03756dbc3bd57a08deb5cf7521dead63b6ca3296
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel/__init__.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/connectivity-matrices/underlay/tunnels/tunnel. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tunnel_name','__sharing',)
+
+ _yang_name = 'tunnel'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'connectivity-matrices', 'underlay', 'tunnels', 'tunnel']
+
+ def _get_tunnel_name(self):
+ """
+ Getter method for tunnel_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel/tunnel_name (string)
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ return self.__tunnel_name
+
+ def _set_tunnel_name(self, v, load=False):
+ """
+ Setter method for tunnel_name, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel/tunnel_name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_name() directly.
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__tunnel_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_name(self):
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+ tunnel_name = __builtin__.property(_get_tunnel_name, _set_tunnel_name)
+ sharing = __builtin__.property(_get_sharing, _set_sharing)
+
+
+ _pyangbind_elements = OrderedDict([('tunnel_name', tunnel_name), ('sharing', sharing), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/underlay_topology/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/underlay_topology/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e4a62679917d02b57e56d464b0f9c59fd8b1ea9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/te_node_attributes/underlay_topology/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class underlay_topology(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/te-node-attributes/underlay-topology. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: When an abstract node encapsulates a topology, the
+attributes in this container point to said topology.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref',)
+
+ _yang_name = 'underlay-topology'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'te-node-attributes', 'underlay-topology']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/underlay_topology/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/te_node_attributes/underlay_topology/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..92fbb57f7371ee17f476c0f2f5a3baa02a5ecab8
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/__init__.py
@@ -0,0 +1,597 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import client_layer_adaptation
+from . import local_link_connectivities
+from . import geolocation
+from . import statistics
+from . import supporting_tunnel_termination_point
+class tunnel_termination_point(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A termination point can terminate a tunnel.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tunnel_tp_id','__admin_status','__name','__switching_capability','__encoding','__inter_layer_lock_id','__protection_type','__client_layer_adaptation','__local_link_connectivities','__oper_status','__geolocation','__statistics','__supporting_tunnel_termination_point',)
+
+ _yang_name = 'tunnel-termination-point'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tunnel_tp_id = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="tunnel-tp-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ self.__admin_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ self.__switching_capability = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__encoding = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__inter_layer_lock_id = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="inter-layer-lock-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__client_layer_adaptation = YANGDynClass(base=client_layer_adaptation.client_layer_adaptation, is_container='container', yang_name="client-layer-adaptation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__local_link_connectivities = YANGDynClass(base=local_link_connectivities.local_link_connectivities, is_container='container', yang_name="local-link-connectivities", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__oper_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)
+ self.__geolocation = YANGDynClass(base=geolocation.geolocation, is_container='container', yang_name="geolocation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__statistics = YANGDynClass(base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__supporting_tunnel_termination_point = YANGDynClass(base=YANGListType("node_ref tunnel_tp_ref",supporting_tunnel_termination_point.supporting_tunnel_termination_point, yang_name="supporting-tunnel-termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='node-ref tunnel-tp-ref', extensions=None), is_container='list', yang_name="supporting-tunnel-termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point']
+
+ def _get_tunnel_tp_id(self):
+ """
+ Getter method for tunnel_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/tunnel_tp_id (binary)
+
+ YANG Description: TTP identifier.
+ """
+ return self.__tunnel_tp_id
+
+ def _set_tunnel_tp_id(self, v, load=False):
+ """
+ Setter method for tunnel_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/tunnel_tp_id (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_tp_id() directly.
+
+ YANG Description: TTP identifier.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="tunnel-tp-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_tp_id must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="tunnel-tp-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)""",
+ })
+
+ self.__tunnel_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_tp_id(self):
+ self.__tunnel_tp_id = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="tunnel-tp-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+
+ def _get_admin_status(self):
+ """
+ Getter method for admin_status, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/admin_status (te-types:te-admin-status)
+
+ YANG Description: The administrative state of the TTP.
+ """
+ return self.__admin_status
+
+ def _set_admin_status(self, v, load=False):
+ """
+ Setter method for admin_status, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/admin_status (te-types:te-admin-status)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_admin_status is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_admin_status() directly.
+
+ YANG Description: The administrative state of the TTP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """admin_status must be of a type compatible with te-types:te-admin-status""",
+ 'defined-type': "te-types:te-admin-status",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)""",
+ })
+
+ self.__admin_status = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_admin_status(self):
+ self.__admin_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="admin-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-admin-status', is_config=True)
+
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/name (string)
+
+ YANG Description: A descriptive name for the TTP.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: A descriptive name for the TTP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+
+ def _get_switching_capability(self):
+ """
+ Getter method for switching_capability, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/switching_capability (identityref)
+
+ YANG Description: Switching capability for this interface.
+ """
+ return self.__switching_capability
+
+ def _set_switching_capability(self, v, load=False):
+ """
+ Setter method for switching_capability, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/switching_capability (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_switching_capability is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_switching_capability() directly.
+
+ YANG Description: Switching capability for this interface.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """switching_capability must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__switching_capability = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_switching_capability(self):
+ self.__switching_capability = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_encoding(self):
+ """
+ Getter method for encoding, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/encoding (identityref)
+
+ YANG Description: Encoding supported by this interface.
+ """
+ return self.__encoding
+
+ def _set_encoding(self, v, load=False):
+ """
+ Setter method for encoding, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/encoding (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_encoding is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_encoding() directly.
+
+ YANG Description: Encoding supported by this interface.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """encoding must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__encoding = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_encoding(self):
+ self.__encoding = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_inter_layer_lock_id(self):
+ """
+ Getter method for inter_layer_lock_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/inter_layer_lock_id (uint32)
+
+ YANG Description: Inter-layer lock ID, used for path computation in a TE
+topology covering multiple layers or multiple regions.
+ """
+ return self.__inter_layer_lock_id
+
+ def _set_inter_layer_lock_id(self, v, load=False):
+ """
+ Setter method for inter_layer_lock_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/inter_layer_lock_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_inter_layer_lock_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_inter_layer_lock_id() directly.
+
+ YANG Description: Inter-layer lock ID, used for path computation in a TE
+topology covering multiple layers or multiple regions.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="inter-layer-lock-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """inter_layer_lock_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="inter-layer-lock-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__inter_layer_lock_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_inter_layer_lock_id(self):
+ self.__inter_layer_lock_id = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="inter-layer-lock-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_protection_type(self):
+ """
+ Getter method for protection_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/protection_type (identityref)
+
+ YANG Description: The protection type that this TTP is capable of.
+ """
+ return self.__protection_type
+
+ def _set_protection_type(self, v, load=False):
+ """
+ Setter method for protection_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/protection_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_protection_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_protection_type() directly.
+
+ YANG Description: The protection type that this TTP is capable of.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """protection_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__protection_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_protection_type(self):
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_client_layer_adaptation(self):
+ """
+ Getter method for client_layer_adaptation, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation (container)
+
+ YANG Description: Contains capability information to support a client-layer
+adaptation in a multi-layer topology.
+ """
+ return self.__client_layer_adaptation
+
+ def _set_client_layer_adaptation(self, v, load=False):
+ """
+ Setter method for client_layer_adaptation, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_client_layer_adaptation is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_client_layer_adaptation() directly.
+
+ YANG Description: Contains capability information to support a client-layer
+adaptation in a multi-layer topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=client_layer_adaptation.client_layer_adaptation, is_container='container', yang_name="client-layer-adaptation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """client_layer_adaptation must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=client_layer_adaptation.client_layer_adaptation, is_container='container', yang_name="client-layer-adaptation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__client_layer_adaptation = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_client_layer_adaptation(self):
+ self.__client_layer_adaptation = YANGDynClass(base=client_layer_adaptation.client_layer_adaptation, is_container='container', yang_name="client-layer-adaptation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_local_link_connectivities(self):
+ """
+ Getter method for local_link_connectivities, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities (container)
+
+ YANG Description: Contains an LLCL for a TTP on a TE node.
+ """
+ return self.__local_link_connectivities
+
+ def _set_local_link_connectivities(self, v, load=False):
+ """
+ Setter method for local_link_connectivities, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_local_link_connectivities is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_local_link_connectivities() directly.
+
+ YANG Description: Contains an LLCL for a TTP on a TE node.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=local_link_connectivities.local_link_connectivities, is_container='container', yang_name="local-link-connectivities", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """local_link_connectivities must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=local_link_connectivities.local_link_connectivities, is_container='container', yang_name="local-link-connectivities", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__local_link_connectivities = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_local_link_connectivities(self):
+ self.__local_link_connectivities = YANGDynClass(base=local_link_connectivities.local_link_connectivities, is_container='container', yang_name="local-link-connectivities", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_oper_status(self):
+ """
+ Getter method for oper_status, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/oper_status (te-types:te-oper-status)
+
+ YANG Description: The current operational state of the TTP.
+ """
+ return self.__oper_status
+
+ def _set_oper_status(self, v, load=False):
+ """
+ Setter method for oper_status, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/oper_status (te-types:te-oper-status)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_oper_status is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_oper_status() directly.
+
+ YANG Description: The current operational state of the TTP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """oper_status must be of a type compatible with te-types:te-oper-status""",
+ 'defined-type': "te-types:te-oper-status",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)""",
+ })
+
+ self.__oper_status = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_oper_status(self):
+ self.__oper_status = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'up': {}, 'down': {}, 'testing': {}, 'preparing-maintenance': {}, 'maintenance': {}, 'unknown': {}},), is_leaf=True, yang_name="oper-status", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-types:te-oper-status', is_config=False)
+
+
+ def _get_geolocation(self):
+ """
+ Getter method for geolocation, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/geolocation (container)
+
+ YANG Description: Contains a GPS location.
+ """
+ return self.__geolocation
+
+ def _set_geolocation(self, v, load=False):
+ """
+ Setter method for geolocation, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/geolocation (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_geolocation is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_geolocation() directly.
+
+ YANG Description: Contains a GPS location.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=geolocation.geolocation, is_container='container', yang_name="geolocation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """geolocation must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=geolocation.geolocation, is_container='container', yang_name="geolocation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__geolocation = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_geolocation(self):
+ self.__geolocation = YANGDynClass(base=geolocation.geolocation, is_container='container', yang_name="geolocation", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_statistics(self):
+ """
+ Getter method for statistics, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/statistics (container)
+
+ YANG Description: Statistics data.
+ """
+ return self.__statistics
+
+ def _set_statistics(self, v, load=False):
+ """
+ Setter method for statistics, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/statistics (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_statistics is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_statistics() directly.
+
+ YANG Description: Statistics data.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """statistics must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__statistics = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_statistics(self):
+ self.__statistics = YANGDynClass(base=statistics.statistics, is_container='container', yang_name="statistics", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_supporting_tunnel_termination_point(self):
+ """
+ Getter method for supporting_tunnel_termination_point, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/supporting_tunnel_termination_point (list)
+
+ YANG Description: Identifies the TTPs on which this TTP depends.
+ """
+ return self.__supporting_tunnel_termination_point
+
+ def _set_supporting_tunnel_termination_point(self, v, load=False):
+ """
+ Setter method for supporting_tunnel_termination_point, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/supporting_tunnel_termination_point (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_supporting_tunnel_termination_point is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_supporting_tunnel_termination_point() directly.
+
+ YANG Description: Identifies the TTPs on which this TTP depends.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("node_ref tunnel_tp_ref",supporting_tunnel_termination_point.supporting_tunnel_termination_point, yang_name="supporting-tunnel-termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='node-ref tunnel-tp-ref', extensions=None), is_container='list', yang_name="supporting-tunnel-termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """supporting_tunnel_termination_point must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("node_ref tunnel_tp_ref",supporting_tunnel_termination_point.supporting_tunnel_termination_point, yang_name="supporting-tunnel-termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='node-ref tunnel-tp-ref', extensions=None), is_container='list', yang_name="supporting-tunnel-termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__supporting_tunnel_termination_point = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_supporting_tunnel_termination_point(self):
+ self.__supporting_tunnel_termination_point = YANGDynClass(base=YANGListType("node_ref tunnel_tp_ref",supporting_tunnel_termination_point.supporting_tunnel_termination_point, yang_name="supporting-tunnel-termination-point", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='node-ref tunnel-tp-ref', extensions=None), is_container='list', yang_name="supporting-tunnel-termination-point", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ tunnel_tp_id = __builtin__.property(_get_tunnel_tp_id, _set_tunnel_tp_id)
+ admin_status = __builtin__.property(_get_admin_status, _set_admin_status)
+ name = __builtin__.property(_get_name, _set_name)
+ switching_capability = __builtin__.property(_get_switching_capability, _set_switching_capability)
+ encoding = __builtin__.property(_get_encoding, _set_encoding)
+ inter_layer_lock_id = __builtin__.property(_get_inter_layer_lock_id, _set_inter_layer_lock_id)
+ protection_type = __builtin__.property(_get_protection_type, _set_protection_type)
+ client_layer_adaptation = __builtin__.property(_get_client_layer_adaptation, _set_client_layer_adaptation)
+ local_link_connectivities = __builtin__.property(_get_local_link_connectivities, _set_local_link_connectivities)
+ oper_status = __builtin__.property(_get_oper_status)
+ geolocation = __builtin__.property(_get_geolocation)
+ statistics = __builtin__.property(_get_statistics)
+ supporting_tunnel_termination_point = __builtin__.property(_get_supporting_tunnel_termination_point, _set_supporting_tunnel_termination_point)
+
+
+ _pyangbind_elements = OrderedDict([('tunnel_tp_id', tunnel_tp_id), ('admin_status', admin_status), ('name', name), ('switching_capability', switching_capability), ('encoding', encoding), ('inter_layer_lock_id', inter_layer_lock_id), ('protection_type', protection_type), ('client_layer_adaptation', client_layer_adaptation), ('local_link_connectivities', local_link_connectivities), ('oper_status', oper_status), ('geolocation', geolocation), ('statistics', statistics), ('supporting_tunnel_termination_point', supporting_tunnel_termination_point), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..35927a2b6d4cfdb6772293b24523657e9bde3e3d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/__init__.py
@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import switching_capability
+class client_layer_adaptation(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/client-layer-adaptation. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains capability information to support a client-layer
+adaptation in a multi-layer topology.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__switching_capability',)
+
+ _yang_name = 'client-layer-adaptation'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__switching_capability = YANGDynClass(base=YANGListType("switching_capability encoding",switching_capability.switching_capability, yang_name="switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'client-layer-adaptation']
+
+ def _get_switching_capability(self):
+ """
+ Getter method for switching_capability, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability (list)
+
+ YANG Description: List of supported switching capabilities.
+ """
+ return self.__switching_capability
+
+ def _set_switching_capability(self, v, load=False):
+ """
+ Setter method for switching_capability, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_switching_capability is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_switching_capability() directly.
+
+ YANG Description: List of supported switching capabilities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("switching_capability encoding",switching_capability.switching_capability, yang_name="switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """switching_capability must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("switching_capability encoding",switching_capability.switching_capability, yang_name="switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__switching_capability = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_switching_capability(self):
+ self.__switching_capability = YANGDynClass(base=YANGListType("switching_capability encoding",switching_capability.switching_capability, yang_name="switching-capability", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='switching-capability encoding', extensions=None), is_container='list', yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ switching_capability = __builtin__.property(_get_switching_capability, _set_switching_capability)
+
+
+ _pyangbind_elements = OrderedDict([('switching_capability', switching_capability), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f565ac105c144b0cede7abcf7171faea22f4fff
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/__init__.py
@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+class switching_capability(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/client-layer-adaptation/switching-capability. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of supported switching capabilities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__switching_capability','__encoding','__te_bandwidth',)
+
+ _yang_name = 'switching-capability'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__switching_capability = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__encoding = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'client-layer-adaptation', 'switching-capability']
+
+ def _get_switching_capability(self):
+ """
+ Getter method for switching_capability, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/switching_capability (identityref)
+
+ YANG Description: Switching capability for the client-layer adaptation.
+ """
+ return self.__switching_capability
+
+ def _set_switching_capability(self, v, load=False):
+ """
+ Setter method for switching_capability, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/switching_capability (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_switching_capability is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_switching_capability() directly.
+
+ YANG Description: Switching capability for the client-layer adaptation.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """switching_capability must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__switching_capability = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_switching_capability(self):
+ self.__switching_capability = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-psc1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-evpl': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-l2sc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-tdm': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-otn': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-dcsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-lsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:switching-fsc': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="switching-capability", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_encoding(self):
+ """
+ Getter method for encoding, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/encoding (identityref)
+
+ YANG Description: Encoding supported by the client-layer adaptation.
+ """
+ return self.__encoding
+
+ def _set_encoding(self, v, load=False):
+ """
+ Setter method for encoding, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/encoding (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_encoding is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_encoding() directly.
+
+ YANG Description: Encoding supported by the client-layer adaptation.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """encoding must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__encoding = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_encoding(self):
+ self.__encoding = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-packet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-ethernet': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-pdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-sdh': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-digital-wrapper': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-lambda': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-fiber-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-oduk': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-optical-channel': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-encoding-line': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="encoding", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ switching_capability = __builtin__.property(_get_switching_capability, _set_switching_capability)
+ encoding = __builtin__.property(_get_encoding, _set_encoding)
+ te_bandwidth = __builtin__.property(_get_te_bandwidth, _set_te_bandwidth)
+
+
+ _pyangbind_elements = OrderedDict([('switching_capability', switching_capability), ('encoding', encoding), ('te_bandwidth', te_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..52516d7596ef2a4a35fe0c9f5613b7d11325dc8f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/client-layer-adaptation/switching-capability/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'client-layer-adaptation', 'switching-capability', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth, _set_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_bandwidth']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f44ede78bd97cc08792454e82392145da7fff76
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/__init__.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/client-layer-adaptation/switching-capability/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist','__odtu_flex_type',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'client-layer-adaptation', 'switching-capability', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+
+
+ def _get_odtu_flex_type(self):
+ """
+ Getter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+terminated on this OTN Tunnel Termination Point
+(TTP).
+ """
+ return self.__odtu_flex_type
+
+ def _set_odtu_flex_type(self, v, load=False):
+ """
+ Setter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odtu_flex_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odtu_flex_type() directly.
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+terminated on this OTN Tunnel Termination Point
+(TTP).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odtu_flex_type must be of a type compatible with l1-types:odtu-flex-type""",
+ 'defined-type': "l1-types:odtu-flex-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)""",
+ })
+
+ self.__odtu_flex_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odtu_flex_type(self):
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+
+ odulist = __builtin__.property(_get_odulist, _set_odulist)
+ odtu_flex_type = __builtin__.property(_get_odtu_flex_type, _set_odtu_flex_type)
+
+ __choices__ = {'technology': {'otn': ['odulist', 'odtu_flex_type']}}
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ('odtu_flex_type', odtu_flex_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4cb37ddf48866ddc9846bde21cab02a01eb9255
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/client-layer-adaptation/switching-capability/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'client-layer-adaptation', 'switching-capability', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ odu_type = __builtin__.property(_get_odu_type, _set_odu_type)
+ number = __builtin__.property(_get_number, _set_number)
+ ts_number = __builtin__.property(_get_ts_number, _set_ts_number)
+
+ __choices__ = {'technology': {'otn': ['odu_type', 'number', 'ts_number']}}
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/geolocation/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/geolocation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..60eedb630beaabab4d10b6ad562533d0a3c450c4
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/geolocation/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class geolocation(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/geolocation. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains a GPS location.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__altitude','__latitude','__longitude',)
+
+ _yang_name = 'geolocation'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__altitude = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-9223372036854775808..9223372036854775807']}, int_size=64), is_leaf=True, yang_name="altitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int64', is_config=False)
+ self.__latitude = YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-90..90']}), is_leaf=True, yang_name="latitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+ self.__longitude = YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-180..180']}), is_leaf=True, yang_name="longitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'geolocation']
+
+ def _get_altitude(self):
+ """
+ Getter method for altitude, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/geolocation/altitude (int64)
+
+ YANG Description: Distance above sea level.
+ """
+ return self.__altitude
+
+ def _set_altitude(self, v, load=False):
+ """
+ Setter method for altitude, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/geolocation/altitude (int64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_altitude is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_altitude() directly.
+
+ YANG Description: Distance above sea level.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-9223372036854775808..9223372036854775807']}, int_size=64), is_leaf=True, yang_name="altitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """altitude must be of a type compatible with int64""",
+ 'defined-type': "int64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-9223372036854775808..9223372036854775807']}, int_size=64), is_leaf=True, yang_name="altitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int64', is_config=False)""",
+ })
+
+ self.__altitude = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_altitude(self):
+ self.__altitude = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-9223372036854775808..9223372036854775807']}, int_size=64), is_leaf=True, yang_name="altitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int64', is_config=False)
+
+
+ def _get_latitude(self):
+ """
+ Getter method for latitude, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/geolocation/latitude (geographic-coordinate-degree)
+
+ YANG Description: Relative position north or south on the Earth's surface.
+ """
+ return self.__latitude
+
+ def _set_latitude(self, v, load=False):
+ """
+ Setter method for latitude, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/geolocation/latitude (geographic-coordinate-degree)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_latitude is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_latitude() directly.
+
+ YANG Description: Relative position north or south on the Earth's surface.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-90..90']}), is_leaf=True, yang_name="latitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """latitude must be of a type compatible with geographic-coordinate-degree""",
+ 'defined-type': "ietf-te-topology:geographic-coordinate-degree",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-90..90']}), is_leaf=True, yang_name="latitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)""",
+ })
+
+ self.__latitude = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_latitude(self):
+ self.__latitude = YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-90..90']}), is_leaf=True, yang_name="latitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+
+
+ def _get_longitude(self):
+ """
+ Getter method for longitude, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/geolocation/longitude (geographic-coordinate-degree)
+
+ YANG Description: Angular distance east or west on the Earth's surface.
+ """
+ return self.__longitude
+
+ def _set_longitude(self, v, load=False):
+ """
+ Setter method for longitude, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/geolocation/longitude (geographic-coordinate-degree)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_longitude is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_longitude() directly.
+
+ YANG Description: Angular distance east or west on the Earth's surface.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-180..180']}), is_leaf=True, yang_name="longitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """longitude must be of a type compatible with geographic-coordinate-degree""",
+ 'defined-type': "ietf-te-topology:geographic-coordinate-degree",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-180..180']}), is_leaf=True, yang_name="longitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)""",
+ })
+
+ self.__longitude = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_longitude(self):
+ self.__longitude = YANGDynClass(base=RestrictedClassType(base_type=RestrictedPrecisionDecimalType(precision=8), restriction_dict={'range': ['-180..180']}), is_leaf=True, yang_name="longitude", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='geographic-coordinate-degree', is_config=False)
+
+ altitude = __builtin__.property(_get_altitude)
+ latitude = __builtin__.property(_get_latitude)
+ longitude = __builtin__.property(_get_longitude)
+
+
+ _pyangbind_elements = OrderedDict([('altitude', altitude), ('latitude', latitude), ('longitude', longitude), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..309e87f52d489f0d2f62db7f7eee13eeadf527e1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/__init__.py
@@ -0,0 +1,418 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restrictions
+from . import underlay
+from . import path_constraints
+from . import optimizations
+from . import path_properties
+from . import local_link_connectivity
+class local_link_connectivities(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Contains an LLCL for a TTP on a TE node.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__number_of_entries','__label_restrictions','__is_allowed','__underlay','__path_constraints','__optimizations','__path_properties','__local_link_connectivity',)
+
+ _yang_name = 'local-link-connectivities'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__number_of_entries = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=True)
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__local_link_connectivity = YANGDynClass(base=YANGListType("link_tp_ref",local_link_connectivity.local_link_connectivity, yang_name="local-link-connectivity", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='link-tp-ref', extensions=None), is_container='list', yang_name="local-link-connectivity", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities']
+
+ def _get_number_of_entries(self):
+ """
+ Getter method for number_of_entries, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/number_of_entries (uint16)
+
+ YANG Description: The number of LLCL entries.
+If this number is specified in the configuration request,
+the number is the requested number of entries, which may
+not all be listed in the list;
+if this number is reported in the state data,
+the number is the current number of operational entries.
+ """
+ return self.__number_of_entries
+
+ def _set_number_of_entries(self, v, load=False):
+ """
+ Setter method for number_of_entries, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/number_of_entries (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number_of_entries is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number_of_entries() directly.
+
+ YANG Description: The number of LLCL entries.
+If this number is specified in the configuration request,
+the number is the requested number of entries, which may
+not all be listed in the list;
+if this number is reported in the state data,
+the number is the current number of operational entries.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number_of_entries must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__number_of_entries = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number_of_entries(self):
+ self.__number_of_entries = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number-of-entries", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint16', is_config=True)
+
+
+ def _get_label_restrictions(self):
+ """
+ Getter method for label_restrictions, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions (container)
+
+ YANG Description: The label restrictions container.
+ """
+ return self.__label_restrictions
+
+ def _set_label_restrictions(self, v, load=False):
+ """
+ Setter method for label_restrictions, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restrictions is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restrictions() directly.
+
+ YANG Description: The label restrictions container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restrictions must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_restrictions = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restrictions(self):
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_is_allowed(self):
+ """
+ Getter method for is_allowed, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/is_allowed (boolean)
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ return self.__is_allowed
+
+ def _set_is_allowed(self, v, load=False):
+ """
+ Setter method for is_allowed, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/is_allowed (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_allowed is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_allowed() directly.
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_allowed must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__is_allowed = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_allowed(self):
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_underlay(self):
+ """
+ Getter method for underlay, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay (container)
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ return self.__underlay
+
+ def _set_underlay(self, v, load=False):
+ """
+ Setter method for underlay, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_underlay is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_underlay() directly.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """underlay must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__underlay = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_underlay(self):
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_constraints(self):
+ """
+ Getter method for path_constraints, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints (container)
+
+ YANG Description: TE named path constraints container.
+ """
+ return self.__path_constraints
+
+ def _set_path_constraints(self, v, load=False):
+ """
+ Setter method for path_constraints, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_constraints is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_constraints() directly.
+
+ YANG Description: TE named path constraints container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_constraints must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_constraints = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_constraints(self):
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_optimizations(self):
+ """
+ Getter method for optimizations, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__optimizations
+
+ def _set_optimizations(self, v, load=False):
+ """
+ Setter method for optimizations, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimizations is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimizations() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimizations must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__optimizations = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimizations(self):
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_properties(self):
+ """
+ Getter method for path_properties, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties (container)
+
+ YANG Description: The TE path properties.
+ """
+ return self.__path_properties
+
+ def _set_path_properties(self, v, load=False):
+ """
+ Setter method for path_properties, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_properties is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_properties() directly.
+
+ YANG Description: The TE path properties.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_properties must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_properties = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_properties(self):
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_local_link_connectivity(self):
+ """
+ Getter method for local_link_connectivity, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity (list)
+
+ YANG Description: The termination capabilities between the TTP and the LTP.
+This capability information can be used to compute
+the tunnel path.
+The Interface Adjustment Capability Descriptors (IACDs)
+(defined in RFC 6001) on each LTP can be derived from
+this list.
+ """
+ return self.__local_link_connectivity
+
+ def _set_local_link_connectivity(self, v, load=False):
+ """
+ Setter method for local_link_connectivity, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_local_link_connectivity is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_local_link_connectivity() directly.
+
+ YANG Description: The termination capabilities between the TTP and the LTP.
+This capability information can be used to compute
+the tunnel path.
+The Interface Adjustment Capability Descriptors (IACDs)
+(defined in RFC 6001) on each LTP can be derived from
+this list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("link_tp_ref",local_link_connectivity.local_link_connectivity, yang_name="local-link-connectivity", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='link-tp-ref', extensions=None), is_container='list', yang_name="local-link-connectivity", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """local_link_connectivity must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("link_tp_ref",local_link_connectivity.local_link_connectivity, yang_name="local-link-connectivity", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='link-tp-ref', extensions=None), is_container='list', yang_name="local-link-connectivity", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__local_link_connectivity = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_local_link_connectivity(self):
+ self.__local_link_connectivity = YANGDynClass(base=YANGListType("link_tp_ref",local_link_connectivity.local_link_connectivity, yang_name="local-link-connectivity", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='link-tp-ref', extensions=None), is_container='list', yang_name="local-link-connectivity", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ number_of_entries = __builtin__.property(_get_number_of_entries, _set_number_of_entries)
+ label_restrictions = __builtin__.property(_get_label_restrictions, _set_label_restrictions)
+ is_allowed = __builtin__.property(_get_is_allowed, _set_is_allowed)
+ underlay = __builtin__.property(_get_underlay, _set_underlay)
+ path_constraints = __builtin__.property(_get_path_constraints, _set_path_constraints)
+ optimizations = __builtin__.property(_get_optimizations, _set_optimizations)
+ path_properties = __builtin__.property(_get_path_properties)
+ local_link_connectivity = __builtin__.property(_get_local_link_connectivity, _set_local_link_connectivity)
+
+
+ _pyangbind_elements = OrderedDict([('number_of_entries', number_of_entries), ('label_restrictions', label_restrictions), ('is_allowed', is_allowed), ('underlay', underlay), ('path_constraints', path_constraints), ('optimizations', optimizations), ('path_properties', path_properties), ('local_link_connectivity', local_link_connectivity), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7170e479811b3ec5d8576646bcf18677541eae62
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restriction
+class label_restrictions(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The label restrictions container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__label_restriction',)
+
+ _yang_name = 'label-restrictions'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions']
+
+ def _get_label_restriction(self):
+ """
+ Getter method for label_restriction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction (list)
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ return self.__label_restriction
+
+ def _set_label_restriction(self, v, load=False):
+ """
+ Setter method for label_restriction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restriction() directly.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restriction must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__label_restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restriction(self):
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ label_restriction = __builtin__.property(_get_label_restriction, _set_label_restriction)
+
+
+ _pyangbind_elements = OrderedDict([('label_restriction', label_restriction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6bb6db97a047b6d5c290b75b80088bfe46913b02
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/__init__.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_start
+from . import label_end
+from . import label_step
+from . import otn_label_range
+from . import ethernet_label_range
+class label_restriction(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restriction','__index','__label_start','__label_end','__label_step','__range_bitmap','__otn_label_range','__ethernet_label_range',)
+
+ _yang_name = 'label-restriction'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction']
+
+ def _get_restriction(self):
+ """
+ Getter method for restriction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/restriction (enumeration)
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ return self.__restriction
+
+ def _set_restriction(self, v, load=False):
+ """
+ Setter method for restriction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/restriction (enumeration)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restriction() directly.
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restriction must be of a type compatible with enumeration""",
+ 'defined-type': "ietf-te-topology:enumeration",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)""",
+ })
+
+ self.__restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restriction(self):
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/index (uint32)
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_label_start(self):
+ """
+ Getter method for label_start, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start (container)
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ return self.__label_start
+
+ def _set_label_start(self, v, load=False):
+ """
+ Setter method for label_start, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_start is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_start() directly.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_start must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_start = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_start(self):
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_end(self):
+ """
+ Getter method for label_end, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end (container)
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ return self.__label_end
+
+ def _set_label_end(self, v, load=False):
+ """
+ Setter method for label_end, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_end is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_end() directly.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_end must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_end = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_end(self):
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_step(self):
+ """
+ Getter method for label_step, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step (container)
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ return self.__label_step
+
+ def _set_label_step(self, v, load=False):
+ """
+ Setter method for label_step, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_step() directly.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_step must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_step(self):
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_range_bitmap(self):
+ """
+ Getter method for range_bitmap, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ return self.__range_bitmap
+
+ def _set_range_bitmap(self, v, load=False):
+ """
+ Setter method for range_bitmap, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_bitmap is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_bitmap() directly.
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_bitmap must be of a type compatible with yang:hex-string""",
+ 'defined-type': "yang:hex-string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)""",
+ })
+
+ self.__range_bitmap = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_bitmap(self):
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+
+
+ def _get_otn_label_range(self):
+ """
+ Getter method for otn_label_range, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range (container)
+
+ YANG Description: Label range information for OTN.
+ """
+ return self.__otn_label_range
+
+ def _set_otn_label_range(self, v, load=False):
+ """
+ Setter method for otn_label_range, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_label_range() directly.
+
+ YANG Description: Label range information for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_label_range(self):
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_ethernet_label_range(self):
+ """
+ Getter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/ethernet_label_range (container)
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ return self.__ethernet_label_range
+
+ def _set_ethernet_label_range(self, v, load=False):
+ """
+ Setter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/ethernet_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ethernet_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ethernet_label_range() directly.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ethernet_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__ethernet_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ethernet_label_range(self):
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ restriction = __builtin__.property(_get_restriction, _set_restriction)
+ index = __builtin__.property(_get_index, _set_index)
+ label_start = __builtin__.property(_get_label_start, _set_label_start)
+ label_end = __builtin__.property(_get_label_end, _set_label_end)
+ label_step = __builtin__.property(_get_label_step, _set_label_step)
+ range_bitmap = __builtin__.property(_get_range_bitmap, _set_range_bitmap)
+ otn_label_range = __builtin__.property(_get_otn_label_range, _set_otn_label_range)
+ ethernet_label_range = __builtin__.property(_get_ethernet_label_range, _set_ethernet_label_range)
+
+
+ _pyangbind_elements = OrderedDict([('restriction', restriction), ('index', index), ('label_start', label_start), ('label_end', label_end), ('label_step', label_step), ('range_bitmap', range_bitmap), ('otn_label_range', otn_label_range), ('ethernet_label_range', ethernet_label_range), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/ethernet_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/ethernet_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ee376c6a7df9fdbee967d382797a74126c05f56
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/ethernet_label_range/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ethernet_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction/ethernet-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tag_type','__priority',)
+
+ _yang_name = 'ethernet-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction', 'ethernet-label-range']
+
+ def _get_tag_type(self):
+ """
+ Getter method for tag_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+
+ YANG Description: VLAN tag type.
+ """
+ return self.__tag_type
+
+ def _set_tag_type(self, v, load=False):
+ """
+ Setter method for tag_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tag_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tag_type() directly.
+
+ YANG Description: VLAN tag type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tag_type must be of a type compatible with etht-types:eth-tag-type""",
+ 'defined-type': "etht-types:eth-tag-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)""",
+ })
+
+ self.__tag_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tag_type(self):
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+
+ YANG Description: priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ tag_type = __builtin__.property(_get_tag_type, _set_tag_type)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('tag_type', tag_type), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..e6bcde2cf63e6308e080f14000153b02c2c907fe
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_end(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction/label-end. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-end'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction', 'label-end']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..d964dca5c1af89e12a0f8f24f4fc1633e1054e5a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction/label-end/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction', 'label-end', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..360a1223487e55f8e2ba8a86690025ee7973a9a0
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction/label-end/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction', 'label-end', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..438d60e5b369b0b6ef5d3d7e90ce1d73b8373a05
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_start(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction/label-start. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-start'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction', 'label-start']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..8e14efa20446bf26b79d2976780eab84d73465d2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction/label-start/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction', 'label-start', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..56b84bbbdd84e3d8688b21d2ac1aeaa683471a86
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction/label-start/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction', 'label-start', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..c349c4d913142f494bea3dd6af4b17c1fe153d49
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class label_step(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction/label-step. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_step',)
+
+ _yang_name = 'label-step'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction', 'label-step']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/generic (int32)
+
+ YANG Description: Label range step.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/generic (int32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Label range step.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with int32""",
+ 'defined-type': "int32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/otn (container)
+
+ YANG Description: Label step for OTN
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label step for OTN
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_step(self):
+ """
+ Getter method for eth_step, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/eth_step (uint16)
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ return self.__eth_step
+
+ def _set_eth_step(self, v, load=False):
+ """
+ Setter method for eth_step, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/eth_step (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_step() directly.
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_step must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__eth_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_step(self):
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_step = __builtin__.property(_get_eth_step, _set_eth_step)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_step']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_step', eth_step), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a0f6d7aebfdc5b3facdf88d2daae95138107502
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/otn/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction/label-step/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label step for OTN
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction', 'label-step', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfc2cd1e0e44c93eedd87a9fd2d41467feaef47d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/label-restrictions/label-restriction/otn-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label range information for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__range_type','__tsg','__odu_type_list','__priority',)
+
+ _yang_name = 'otn-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'label-restrictions', 'label-restriction', 'otn-label-range']
+
+ def _get_range_type(self):
+ """
+ Getter method for range_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ return self.__range_type
+
+ def _set_range_type(self, v, load=False):
+ """
+ Setter method for range_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_type() directly.
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_type must be of a type compatible with otn-label-range-type""",
+ 'defined-type': "ietf-otn-topology:otn-label-range-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)""",
+ })
+
+ self.__range_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_type(self):
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_odu_type_list(self):
+ """
+ Getter method for odu_type_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ return self.__odu_type_list
+
+ def _set_odu_type_list(self, v, load=False):
+ """
+ Setter method for odu_type_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type_list() directly.
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type_list must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type_list(self):
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ range_type = __builtin__.property(_get_range_type, _set_range_type)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ odu_type_list = __builtin__.property(_get_odu_type_list, _set_odu_type_list)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('range_type', range_type), ('tsg', tsg), ('odu_type_list', odu_type_list), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b7a646ea671ab3fe76eb70143aea289f4c130628
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/__init__.py
@@ -0,0 +1,368 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restrictions
+from . import underlay
+from . import path_constraints
+from . import optimizations
+from . import path_properties
+class local_link_connectivity(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The termination capabilities between the TTP and the LTP.
+This capability information can be used to compute
+the tunnel path.
+The Interface Adjustment Capability Descriptors (IACDs)
+(defined in RFC 6001) on each LTP can be derived from
+this list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_ref','__label_restrictions','__is_allowed','__underlay','__path_constraints','__optimizations','__path_properties',)
+
+ _yang_name = 'local-link-connectivity'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity']
+
+ def _get_link_tp_ref(self):
+ """
+ Getter method for link_tp_ref, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/link_tp_ref (leafref)
+
+ YANG Description: LTP.
+ """
+ return self.__link_tp_ref
+
+ def _set_link_tp_ref(self, v, load=False):
+ """
+ Setter method for link_tp_ref, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/link_tp_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_ref() directly.
+
+ YANG Description: LTP.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="link-tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__link_tp_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_ref(self):
+ self.__link_tp_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="link-tp-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_label_restrictions(self):
+ """
+ Getter method for label_restrictions, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions (container)
+
+ YANG Description: The label restrictions container.
+ """
+ return self.__label_restrictions
+
+ def _set_label_restrictions(self, v, load=False):
+ """
+ Setter method for label_restrictions, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restrictions is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restrictions() directly.
+
+ YANG Description: The label restrictions container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restrictions must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_restrictions = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restrictions(self):
+ self.__label_restrictions = YANGDynClass(base=label_restrictions.label_restrictions, is_container='container', yang_name="label-restrictions", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_is_allowed(self):
+ """
+ Getter method for is_allowed, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/is_allowed (boolean)
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ return self.__is_allowed
+
+ def _set_is_allowed(self, v, load=False):
+ """
+ Setter method for is_allowed, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/is_allowed (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_is_allowed is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_is_allowed() directly.
+
+ YANG Description: 'true' - switching is allowed;
+'false' - switching is disallowed.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """is_allowed must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__is_allowed = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_is_allowed(self):
+ self.__is_allowed = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="is-allowed", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_underlay(self):
+ """
+ Getter method for underlay, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay (container)
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ return self.__underlay
+
+ def _set_underlay(self, v, load=False):
+ """
+ Setter method for underlay, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_underlay is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_underlay() directly.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """underlay must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__underlay = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_underlay(self):
+ self.__underlay = YANGDynClass(base=underlay.underlay, is_container='container', yang_name="underlay", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_constraints(self):
+ """
+ Getter method for path_constraints, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints (container)
+
+ YANG Description: TE named path constraints container.
+ """
+ return self.__path_constraints
+
+ def _set_path_constraints(self, v, load=False):
+ """
+ Setter method for path_constraints, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_constraints is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_constraints() directly.
+
+ YANG Description: TE named path constraints container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_constraints must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_constraints = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_constraints(self):
+ self.__path_constraints = YANGDynClass(base=path_constraints.path_constraints, is_container='container', yang_name="path-constraints", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_optimizations(self):
+ """
+ Getter method for optimizations, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__optimizations
+
+ def _set_optimizations(self, v, load=False):
+ """
+ Setter method for optimizations, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimizations is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimizations() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimizations must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__optimizations = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimizations(self):
+ self.__optimizations = YANGDynClass(base=optimizations.optimizations, is_container='container', yang_name="optimizations", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_properties(self):
+ """
+ Getter method for path_properties, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties (container)
+
+ YANG Description: The TE path properties.
+ """
+ return self.__path_properties
+
+ def _set_path_properties(self, v, load=False):
+ """
+ Setter method for path_properties, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_properties is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_properties() directly.
+
+ YANG Description: The TE path properties.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_properties must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_properties = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_properties(self):
+ self.__path_properties = YANGDynClass(base=path_properties.path_properties, is_container='container', yang_name="path-properties", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ link_tp_ref = __builtin__.property(_get_link_tp_ref, _set_link_tp_ref)
+ label_restrictions = __builtin__.property(_get_label_restrictions, _set_label_restrictions)
+ is_allowed = __builtin__.property(_get_is_allowed, _set_is_allowed)
+ underlay = __builtin__.property(_get_underlay, _set_underlay)
+ path_constraints = __builtin__.property(_get_path_constraints, _set_path_constraints)
+ optimizations = __builtin__.property(_get_optimizations, _set_optimizations)
+ path_properties = __builtin__.property(_get_path_properties)
+
+
+ _pyangbind_elements = OrderedDict([('link_tp_ref', link_tp_ref), ('label_restrictions', label_restrictions), ('is_allowed', is_allowed), ('underlay', underlay), ('path_constraints', path_constraints), ('optimizations', optimizations), ('path_properties', path_properties), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..37d7f23f2187c3896264636b88d1dbe26eaafe2d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_restriction
+class label_restrictions(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The label restrictions container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__label_restriction',)
+
+ _yang_name = 'label-restrictions'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions']
+
+ def _get_label_restriction(self):
+ """
+ Getter method for label_restriction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction (list)
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ return self.__label_restriction
+
+ def _set_label_restriction(self, v, load=False):
+ """
+ Setter method for label_restriction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_restriction() directly.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_restriction must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__label_restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_restriction(self):
+ self.__label_restriction = YANGDynClass(base=YANGListType("index",label_restriction.label_restriction, yang_name="label-restriction", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="label-restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ label_restriction = __builtin__.property(_get_label_restriction, _set_label_restriction)
+
+
+ _pyangbind_elements = OrderedDict([('label_restriction', label_restriction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..5d5f6509bd6063c7a3dce0d27b36f2db0aded0f1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/__init__.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import label_start
+from . import label_end
+from . import label_step
+from . import otn_label_range
+from . import ethernet_label_range
+class label_restriction(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The absence of the label restrictions container implies
+that all labels are acceptable; otherwise, only restricted
+labels are available.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__restriction','__index','__label_start','__label_end','__label_step','__range_bitmap','__otn_label_range','__ethernet_label_range',)
+
+ _yang_name = 'label-restriction'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction']
+
+ def _get_restriction(self):
+ """
+ Getter method for restriction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/restriction (enumeration)
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ return self.__restriction
+
+ def _set_restriction(self, v, load=False):
+ """
+ Setter method for restriction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/restriction (enumeration)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_restriction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_restriction() directly.
+
+ YANG Description: Indicates whether the list item is inclusive or exclusive.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """restriction must be of a type compatible with enumeration""",
+ 'defined-type': "ietf-te-topology:enumeration",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)""",
+ })
+
+ self.__restriction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_restriction(self):
+ self.__restriction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'inclusive': {}, 'exclusive': {}},), default=six.text_type("inclusive"), is_leaf=True, yang_name="restriction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='enumeration', is_config=True)
+
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/index (uint32)
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: The index of the label restriction list entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_label_start(self):
+ """
+ Getter method for label_start, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start (container)
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ return self.__label_start
+
+ def _set_label_start(self, v, load=False):
+ """
+ Setter method for label_start, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_start is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_start() directly.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_start must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_start = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_start(self):
+ self.__label_start = YANGDynClass(base=label_start.label_start, is_container='container', yang_name="label-start", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_end(self):
+ """
+ Getter method for label_end, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end (container)
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ return self.__label_end
+
+ def _set_label_end(self, v, load=False):
+ """
+ Setter method for label_end, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_end is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_end() directly.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_end must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_end = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_end(self):
+ self.__label_end = YANGDynClass(base=label_end.label_end, is_container='container', yang_name="label-end", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_step(self):
+ """
+ Getter method for label_step, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step (container)
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ return self.__label_step
+
+ def _set_label_step(self, v, load=False):
+ """
+ Setter method for label_step, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_step() directly.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_step must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_step(self):
+ self.__label_step = YANGDynClass(base=label_step.label_step, is_container='container', yang_name="label-step", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_range_bitmap(self):
+ """
+ Getter method for range_bitmap, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ return self.__range_bitmap
+
+ def _set_range_bitmap(self, v, load=False):
+ """
+ Setter method for range_bitmap, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/range_bitmap (yang:hex-string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_bitmap is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_bitmap() directly.
+
+ YANG Description: When there are gaps between 'label-start' and 'label-end',
+this attribute is used to specify the positions
+of the used labels. This is represented in big endian as
+'hex-string'.
+The most significant byte in the hex-string is the farthest
+to the left in the byte sequence. Leading zero bytes in the
+configured value may be omitted for brevity.
+Each bit position in the 'range-bitmap' 'hex-string' maps
+to a label in the range derived from 'label-start'.
+
+For example, assuming that 'label-start' = 16000 and
+'range-bitmap' = 0x01000001, then:
+
+- bit position (0) is set, and the corresponding mapped
+ label from the range is 16000 + (0 * 'label-step') or
+ 16000 for default 'label-step' = 1.
+- bit position (24) is set, and the corresponding mapped
+ label from the range is 16000 + (24 * 'label-step') or
+ 16024 for default 'label-step' = 1.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_bitmap must be of a type compatible with yang:hex-string""",
+ 'defined-type': "yang:hex-string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)""",
+ })
+
+ self.__range_bitmap = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_bitmap(self):
+ self.__range_bitmap = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), is_leaf=True, yang_name="range-bitmap", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='yang:hex-string', is_config=True)
+
+
+ def _get_otn_label_range(self):
+ """
+ Getter method for otn_label_range, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range (container)
+
+ YANG Description: Label range information for OTN.
+ """
+ return self.__otn_label_range
+
+ def _set_otn_label_range(self, v, load=False):
+ """
+ Setter method for otn_label_range, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn_label_range() directly.
+
+ YANG Description: Label range information for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn_label_range(self):
+ self.__otn_label_range = YANGDynClass(base=otn_label_range.otn_label_range, is_container='container', yang_name="otn-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_ethernet_label_range(self):
+ """
+ Getter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/ethernet_label_range (container)
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ return self.__ethernet_label_range
+
+ def _set_ethernet_label_range(self, v, load=False):
+ """
+ Setter method for ethernet_label_range, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/ethernet_label_range (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ethernet_label_range is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ethernet_label_range() directly.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ethernet_label_range must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__ethernet_label_range = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ethernet_label_range(self):
+ self.__ethernet_label_range = YANGDynClass(base=ethernet_label_range.ethernet_label_range, is_container='container', yang_name="ethernet-label-range", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='container', is_config=True)
+
+ restriction = __builtin__.property(_get_restriction, _set_restriction)
+ index = __builtin__.property(_get_index, _set_index)
+ label_start = __builtin__.property(_get_label_start, _set_label_start)
+ label_end = __builtin__.property(_get_label_end, _set_label_end)
+ label_step = __builtin__.property(_get_label_step, _set_label_step)
+ range_bitmap = __builtin__.property(_get_range_bitmap, _set_range_bitmap)
+ otn_label_range = __builtin__.property(_get_otn_label_range, _set_otn_label_range)
+ ethernet_label_range = __builtin__.property(_get_ethernet_label_range, _set_ethernet_label_range)
+
+
+ _pyangbind_elements = OrderedDict([('restriction', restriction), ('index', index), ('label_start', label_start), ('label_end', label_end), ('label_step', label_step), ('range_bitmap', range_bitmap), ('otn_label_range', otn_label_range), ('ethernet_label_range', ethernet_label_range), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/ethernet_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/ethernet_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..17b2f661d64f6db169a22b1cd10bc49f538893b2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/ethernet_label_range/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class ethernet_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction/ethernet-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Ethernet-specific label range related information.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tag_type','__priority',)
+
+ _yang_name = 'ethernet-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction', 'ethernet-label-range']
+
+ def _get_tag_type(self):
+ """
+ Getter method for tag_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+
+ YANG Description: VLAN tag type.
+ """
+ return self.__tag_type
+
+ def _set_tag_type(self, v, load=False):
+ """
+ Setter method for tag_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/ethernet_label_range/tag_type (etht-types:eth-tag-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tag_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tag_type() directly.
+
+ YANG Description: VLAN tag type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tag_type must be of a type compatible with etht-types:eth-tag-type""",
+ 'defined-type': "etht-types:eth-tag-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)""",
+ })
+
+ self.__tag_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tag_type(self):
+ self.__tag_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:c-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 's-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'ietf-eth-tran-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}, 'etht-types:s-vlan-tag-type': {'@module': 'ietf-eth-tran-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-eth-tran-types'}},), is_leaf=True, yang_name="tag-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:eth-tag-type', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+
+ YANG Description: priority.
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/ethernet_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint8', is_config=True)
+
+ tag_type = __builtin__.property(_get_tag_type, _set_tag_type)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('tag_type', tag_type), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..c31cb61453887c3cea67f9e70935fa34140e469e
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_end(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction/label-end. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the ending label if a label range is specified.
+This attribute is not set if a single label is specified.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-end'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction', 'label-end']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..deb12db62a93bb2fed55d87fd9864e12bee11dde
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction/label-end/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction', 'label-end', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..efd7f3ed2d56606b1afb9693993a0842e57f3cb3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction/label-end/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction', 'label-end', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..824467f81b28cb978a87996d0631864753ed91e6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_start(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction/label-start. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: This is the starting label if a label range is specified.
+This is the label value if a single label is specified,
+in which case the 'label-end' attribute is not set.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-start'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction', 'label-start']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..7fddd85cf7bc6dabc2fb9973b516f959b1796665
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction/label-start/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction', 'label-start', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/otn (container)
+
+ YANG Description: Label start or label end for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..44028d6f94f01dc8d99fa990bb36c9cbd85d3dda
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/otn/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction/label-start/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label start or label end for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction', 'label-start', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..58c0b9c3e467c8592bb12617d41499c0d03529df
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class label_step(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction/label-step. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The step increment between labels in the label range.
+The label start/end values will have to be consistent
+with the sign of label step. For example,
+'label-start' < 'label-end' enforces 'label-step' > 0
+'label-start' > 'label-end' enforces 'label-step' < 0.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_step',)
+
+ _yang_name = 'label-step'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction', 'label-step']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/generic (int32)
+
+ YANG Description: Label range step.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/generic (int32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Label range step.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with int32""",
+ 'defined-type': "int32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['-2147483648..2147483647']}, int_size=32)(1), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='int32', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/otn (container)
+
+ YANG Description: Label step for OTN
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label step for OTN
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_step(self):
+ """
+ Getter method for eth_step, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/eth_step (uint16)
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ return self.__eth_step
+
+ def _set_eth_step(self, v, load=False):
+ """
+ Setter method for eth_step, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/eth_step (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_step is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_step() directly.
+
+ YANG Description: Label step which represent possible increments for
+an Ethernet VLAN tag.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_step must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__eth_step = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_step(self):
+ self.__eth_step = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16)(1), is_leaf=True, yang_name="eth-step", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint16', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_step = __builtin__.property(_get_eth_step, _set_eth_step)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_step']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_step', eth_step), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7125ae3a2c00b9dcd82c30958ca9c0911dec1b9d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/otn/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction/label-step/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label step for OTN
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__ts',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction', 'label-step', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('range-type', 'trib-port'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_ts(self):
+ """
+ Getter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ return self.__ts
+
+ def _set_ts(self, v, load=False):
+ """
+ Setter method for ts, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/otn/ts (otn-ts)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts() directly.
+
+ YANG Description: Label step which represents possible increments for
+Tributary Slot (TS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts must be of a type compatible with otn-ts""",
+ 'defined-type': "ietf-otn-topology:otn-ts",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)""",
+ })
+
+ self.__ts = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts(self):
+ self.__ts = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts", parent=self, choice=('range-type', 'trib-slot'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-ts', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ ts = __builtin__.property(_get_ts, _set_ts)
+
+ __choices__ = {'range-type': {'trib-port': ['tpn'], 'trib-slot': ['ts']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('ts', ts), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..54adb557bb093d883e1eb78881222f1d6c9ee898
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/__init__.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn_label_range(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/label-restrictions/label-restriction/otn-label-range. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label range information for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__range_type','__tsg','__odu_type_list','__priority',)
+
+ _yang_name = 'otn-label-range'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'label-restrictions', 'label-restriction', 'otn-label-range']
+
+ def _get_range_type(self):
+ """
+ Getter method for range_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ return self.__range_type
+
+ def _set_range_type(self, v, load=False):
+ """
+ Setter method for range_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/range_type (otn-label-range-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_range_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_range_type() directly.
+
+ YANG Description: The type of range (e.g., TPN or TS)
+to which the label range applies
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """range_type must be of a type compatible with otn-label-range-type""",
+ 'defined-type': "ietf-otn-topology:otn-label-range-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)""",
+ })
+
+ self.__range_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_range_type(self):
+ self.__range_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'trib-slot': {}, 'trib-port': {}},), is_leaf=True, yang_name="range-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-label-range-type', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary slot granularity (TSG) to which the label range
+applies.
+
+This leaf MUST be present when the range-type is TS.
+
+This leaf MAY be omitted when mapping an ODUk over an OTUk
+Link. In this case the range-type is tpn, with only one
+entry (ODUk), and the tpn range has only one value (1).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_odu_type_list(self):
+ """
+ Getter method for odu_type_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ return self.__odu_type_list
+
+ def _set_odu_type_list(self, v, load=False):
+ """
+ Setter method for odu_type_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/odu_type_list (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type_list() directly.
+
+ YANG Description: List of ODU types to which the label range applies.
+
+An Empty odu-type-list means that the label range
+applies to all the supported ODU types.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type_list must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type_list(self):
+ self.__odu_type_list = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},)), is_leaf=False, yang_name="odu-type-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_priority(self):
+ """
+ Getter method for priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ return self.__priority
+
+ def _set_priority(self, v, load=False):
+ """
+ Setter method for priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/otn_label_range/priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_priority() directly.
+
+ YANG Description: Priority in Interface Switching Capability
+Descriptor (ISCD).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_priority(self):
+ self.__priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), is_leaf=True, yang_name="priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint8', is_config=True)
+
+ range_type = __builtin__.property(_get_range_type, _set_range_type)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ odu_type_list = __builtin__.property(_get_odu_type_list, _set_odu_type_list)
+ priority = __builtin__.property(_get_priority, _set_priority)
+
+
+ _pyangbind_elements = OrderedDict([('range_type', range_type), ('tsg', tsg), ('odu_type_list', odu_type_list), ('priority', priority), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3bc26167a6e71530ea7d92582812e55483c86fd3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/__init__.py
@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import optimization_metric
+from . import tiebreakers
+from . import objective_function
+class optimizations(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__optimization_metric','__tiebreakers','__objective_function',)
+
+ _yang_name = 'optimizations'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations']
+
+ def _get_optimization_metric(self):
+ """
+ Getter method for optimization_metric, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__optimization_metric
+
+ def _set_optimization_metric(self, v, load=False):
+ """
+ Setter method for optimization_metric, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimization_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimization_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimization_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__optimization_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimization_metric(self):
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+
+ def _get_tiebreakers(self):
+ """
+ Getter method for tiebreakers, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers (container)
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ return self.__tiebreakers
+
+ def _set_tiebreakers(self, v, load=False):
+ """
+ Setter method for tiebreakers, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreakers is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreakers() directly.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreakers must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tiebreakers = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreakers(self):
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_objective_function(self):
+ """
+ Getter method for objective_function, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/objective_function (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__objective_function
+
+ def _set_objective_function(self, v, load=False):
+ """
+ Setter method for objective_function, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/objective_function (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__objective_function = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function(self):
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ optimization_metric = __builtin__.property(_get_optimization_metric, _set_optimization_metric)
+ tiebreakers = __builtin__.property(_get_tiebreakers, _set_tiebreakers)
+ objective_function = __builtin__.property(_get_objective_function, _set_objective_function)
+
+ __choices__ = {'algorithm': {'metric': ['optimization_metric', 'tiebreakers'], 'objective-function': ['objective_function']}}
+ _pyangbind_elements = OrderedDict([('optimization_metric', optimization_metric), ('tiebreakers', tiebreakers), ('objective_function', objective_function), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/objective_function/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/objective_function/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..302ed483026db4ae6afa8e38646ca609132c8eda
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/objective_function/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class objective_function(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/objective-function. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__objective_function_type',)
+
+ _yang_name = 'objective-function'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'objective-function']
+
+ def _get_objective_function_type(self):
+ """
+ Getter method for objective_function_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/objective_function/objective_function_type (identityref)
+
+ YANG Description: Objective function entry.
+ """
+ return self.__objective_function_type
+
+ def _set_objective_function_type(self, v, load=False):
+ """
+ Setter method for objective_function_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/objective_function/objective_function_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function_type() directly.
+
+ YANG Description: Objective function entry.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__objective_function_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function_type(self):
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ objective_function_type = __builtin__.property(_get_objective_function_type, _set_objective_function_type)
+
+ __choices__ = {'algorithm': {'objective-function': ['objective_function_type']}}
+ _pyangbind_elements = OrderedDict([('objective_function_type', objective_function_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef6ac03d431417d485a346e8192e3b37629e4937
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/__init__.py
@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import explicit_route_exclude_objects
+from . import explicit_route_include_objects
+class optimization_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__weight','__explicit_route_exclude_objects','__explicit_route_include_objects',)
+
+ _yang_name = 'optimization-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/metric_type (identityref)
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_weight(self):
+ """
+ Getter method for weight, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/weight (uint8)
+
+ YANG Description: TE path metric normalization weight.
+ """
+ return self.__weight
+
+ def _set_weight(self, v, load=False):
+ """
+ Setter method for weight, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/weight (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_weight is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_weight() directly.
+
+ YANG Description: TE path metric normalization weight.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """weight must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__weight = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_weight(self):
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_explicit_route_exclude_objects(self):
+ """
+ Getter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ return self.__explicit_route_exclude_objects
+
+ def _set_explicit_route_exclude_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_exclude_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_exclude_objects() directly.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_exclude_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__explicit_route_exclude_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_exclude_objects(self):
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_explicit_route_include_objects(self):
+ """
+ Getter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects (container)
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ return self.__explicit_route_include_objects
+
+ def _set_explicit_route_include_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_include_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_include_objects() directly.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_include_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__explicit_route_include_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_include_objects(self):
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ metric_type = __builtin__.property(_get_metric_type, _set_metric_type)
+ weight = __builtin__.property(_get_weight, _set_weight)
+ explicit_route_exclude_objects = __builtin__.property(_get_explicit_route_exclude_objects, _set_explicit_route_exclude_objects)
+ explicit_route_include_objects = __builtin__.property(_get_explicit_route_include_objects, _set_explicit_route_include_objects)
+
+ __choices__ = {'algorithm': {'metric': ['metric_type', 'weight', 'explicit_route_exclude_objects', 'explicit_route_include_objects']}}
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('weight', weight), ('explicit_route_exclude_objects', explicit_route_exclude_objects), ('explicit_route_include_objects', explicit_route_include_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f81d927f3a7fc066f47ad055904cf65e0bb729a3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_exclude_object
+class explicit_route_exclude_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-exclude-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_exclude_object',)
+
+ _yang_name = 'explicit-route-exclude-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects']
+
+ def _get_route_object_exclude_object(self):
+ """
+ Getter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ return self.__route_object_exclude_object
+
+ def _set_route_object_exclude_object(self, v, load=False):
+ """
+ Setter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_exclude_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_exclude_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_exclude_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__route_object_exclude_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_exclude_object(self):
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ route_object_exclude_object = __builtin__.property(_get_route_object_exclude_object, _set_route_object_exclude_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_exclude_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_exclude_object', route_object_exclude_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ce09fde14ab1f2f1e56ed189aa62110a1ba07a2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
@@ -0,0 +1,365 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+from . import srlg
+class route_object_exclude_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop','__srlg',)
+
+ _yang_name = 'route-object-exclude-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+
+ YANG Description: SRLG container.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+ srlg = __builtin__.property(_get_srlg, _set_srlg)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop'], 'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0cbff483c1e7a2c9999c02c3155508169a8071ce
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5acd3647742511b6b1deca0051576521cdd967aa
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..aadad5c2c2c8d745e7f41c6d7d6ba38fe2537810
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c0b396ee7d0ae6a237131987bf3e8514244893f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bda9afb8438c86eca19dde2b7f4a8c90b8b67064
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c7cd97f18083e5cb1bee25bbefcf3d465f68e7a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fdf3924968411d9f77d42b907982b67ceda3a26
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/__init__.py
@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class srlg(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/srlg. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: SRLG container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__srlg',)
+
+ _yang_name = 'srlg'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__srlg = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'srlg']
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/srlg (uint32)
+
+ YANG Description: SRLG value.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg/srlg (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+ srlg = __builtin__.property(_get_srlg, _set_srlg)
+
+ __choices__ = {'type': {'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5794e333a5155532f3a0af6b0647939d5d4f964
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5e9a3732126f9480005cfee1746e3ce154243af
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_include_object
+class explicit_route_include_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-include-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_include_object',)
+
+ _yang_name = 'explicit-route-include-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_include_object = YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-include-objects']
+
+ def _get_route_object_include_object(self):
+ """
+ Getter method for route_object_include_object, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object (list)
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ return self.__route_object_include_object
+
+ def _set_route_object_include_object(self, v, load=False):
+ """
+ Setter method for route_object_include_object, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_include_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_include_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_include_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__route_object_include_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_include_object(self):
+ self.__route_object_include_object = YANGDynClass(base=YANGListType("index",route_object_include_object.route_object_include_object, yang_name="route-object-include-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-include-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ route_object_include_object = __builtin__.property(_get_route_object_include_object, _set_route_object_include_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_include_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_include_object', route_object_include_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..374536eb4a03613662b8edb0cb12bc447d9e0340
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py
@@ -0,0 +1,325 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class route_object_include_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be included in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'route-object-include-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b9ce19d6fb5071f1285e74ed70a8cf256980397
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b21890c48b0310bf39896972ca3f76bf2f0d91c1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..df8c1361951da40f39c4baef79c1402c08cf7882
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7fef4856ef2c1720a443a226ac6bdbd347097b72
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..97b264f0df4730b294424e89f9d7b7aec427c1e5
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..218283dca241717d1ea5bbd904562ee30751dc59
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce387660e79d92b814eb12f9cabf9777d6cc8bc7
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/optimization-metric/explicit-route-include-objects/route-object-include-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'optimization-metric', 'explicit-route-include-objects', 'route-object-include-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/optimization_metric/explicit_route_include_objects/route_object_include_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5dbea3946289108d2b2c3ddebe78bbfaa158aa05
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers/__init__.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tiebreaker
+class tiebreakers(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/tiebreakers. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tiebreaker',)
+
+ _yang_name = 'tiebreakers'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tiebreaker = YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'tiebreakers']
+
+ def _get_tiebreaker(self):
+ """
+ Getter method for tiebreaker, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers/tiebreaker (list)
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ return self.__tiebreaker
+
+ def _set_tiebreaker(self, v, load=False):
+ """
+ Setter method for tiebreaker, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers/tiebreaker (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreaker is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreaker() directly.
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreaker must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__tiebreaker = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreaker(self):
+ self.__tiebreaker = YANGDynClass(base=YANGListType("tiebreaker_type",tiebreaker.tiebreaker, yang_name="tiebreaker", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tiebreaker-type', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="tiebreaker", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ tiebreaker = __builtin__.property(_get_tiebreaker, _set_tiebreaker)
+
+ __choices__ = {'algorithm': {'metric': ['tiebreaker']}}
+ _pyangbind_elements = OrderedDict([('tiebreaker', tiebreaker), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers/tiebreaker/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers/tiebreaker/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c879cb008a89e64a10388b6d404580a09162a6b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers/tiebreaker/__init__.py
@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tiebreaker(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/optimizations/tiebreakers/tiebreaker. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The list of tiebreaker criteria to apply on an
+equally favored set of paths, in order to pick
+the best.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tiebreaker_type',)
+
+ _yang_name = 'tiebreaker'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tiebreaker_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'optimizations', 'tiebreakers', 'tiebreaker']
+
+ def _get_tiebreaker_type(self):
+ """
+ Getter method for tiebreaker_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers/tiebreaker/tiebreaker_type (identityref)
+
+ YANG Description: Identifies an entry in the list of tiebreakers.
+ """
+ return self.__tiebreaker_type
+
+ def _set_tiebreaker_type(self, v, load=False):
+ """
+ Setter method for tiebreaker_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/tiebreakers/tiebreaker/tiebreaker_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreaker_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreaker_type() directly.
+
+ YANG Description: Identifies an entry in the list of tiebreakers.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreaker_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tiebreaker_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreaker_type(self):
+ self.__tiebreaker_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="tiebreaker-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ tiebreaker_type = __builtin__.property(_get_tiebreaker_type, _set_tiebreaker_type)
+
+ __choices__ = {'algorithm': {'metric': ['tiebreaker_type']}}
+ _pyangbind_elements = OrderedDict([('tiebreaker_type', tiebreaker_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f737852bfcfe03d7e1b344472f9e92029947eccb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/__init__.py
@@ -0,0 +1,523 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_bandwidth
+from . import path_metric_bounds
+from . import path_affinities_values
+from . import path_affinity_names
+from . import path_srlgs_lists
+from . import path_srlgs_names
+class path_constraints(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE named path constraints container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_bandwidth','__link_protection','__setup_priority','__hold_priority','__signaling_type','__path_metric_bounds','__path_affinities_values','__path_affinity_names','__path_srlgs_lists','__path_srlgs_names','__disjointness',)
+
+ _yang_name = 'path-constraints'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__link_protection = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__setup_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__hold_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__signaling_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__path_metric_bounds = YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__disjointness = YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints']
+
+ def _get_te_bandwidth(self):
+ """
+ Getter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth (container)
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ return self.__te_bandwidth
+
+ def _set_te_bandwidth(self, v, load=False):
+ """
+ Setter method for te_bandwidth, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_bandwidth() directly.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_bandwidth must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_bandwidth(self):
+ self.__te_bandwidth = YANGDynClass(base=te_bandwidth.te_bandwidth, is_container='container', yang_name="te-bandwidth", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_link_protection(self):
+ """
+ Getter method for link_protection, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/link_protection (identityref)
+
+ YANG Description: Link protection type required for the links included
+in the computed path.
+ """
+ return self.__link_protection
+
+ def _set_link_protection(self, v, load=False):
+ """
+ Setter method for link_protection, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/link_protection (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_protection is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_protection() directly.
+
+ YANG Description: Link protection type required for the links included
+in the computed path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_protection must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__link_protection = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_protection(self):
+ self.__link_protection = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-shared': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:link-protection-enhanced': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:link-protection-unprotected"), is_leaf=True, yang_name="link-protection", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_setup_priority(self):
+ """
+ Getter method for setup_priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/setup_priority (uint8)
+
+ YANG Description: TE LSP requested setup priority.
+ """
+ return self.__setup_priority
+
+ def _set_setup_priority(self, v, load=False):
+ """
+ Setter method for setup_priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/setup_priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_setup_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_setup_priority() directly.
+
+ YANG Description: TE LSP requested setup priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """setup_priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__setup_priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_setup_priority(self):
+ self.__setup_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="setup-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_hold_priority(self):
+ """
+ Getter method for hold_priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/hold_priority (uint8)
+
+ YANG Description: TE LSP requested hold priority.
+ """
+ return self.__hold_priority
+
+ def _set_hold_priority(self, v, load=False):
+ """
+ Setter method for hold_priority, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/hold_priority (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hold_priority is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hold_priority() directly.
+
+ YANG Description: TE LSP requested hold priority.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hold_priority must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__hold_priority = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hold_priority(self):
+ self.__hold_priority = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), restriction_dict={'range': ['0..7']}), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(7), is_leaf=True, yang_name="hold-priority", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_signaling_type(self):
+ """
+ Getter method for signaling_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/signaling_type (identityref)
+
+ YANG Description: TE tunnel path signaling type.
+ """
+ return self.__signaling_type
+
+ def _set_signaling_type(self, v, load=False):
+ """
+ Setter method for signaling_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/signaling_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_signaling_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_signaling_type() directly.
+
+ YANG Description: TE tunnel path signaling type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """signaling_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__signaling_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_signaling_type(self):
+ self.__signaling_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-static': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-rsvp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-setup-sr': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:path-setup-rsvp"), is_leaf=True, yang_name="signaling-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_path_metric_bounds(self):
+ """
+ Getter method for path_metric_bounds, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds (container)
+
+ YANG Description: TE path metric bounds container.
+ """
+ return self.__path_metric_bounds
+
+ def _set_path_metric_bounds(self, v, load=False):
+ """
+ Setter method for path_metric_bounds, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric_bounds is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric_bounds() directly.
+
+ YANG Description: TE path metric bounds container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric_bounds must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_metric_bounds = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric_bounds(self):
+ self.__path_metric_bounds = YANGDynClass(base=path_metric_bounds.path_metric_bounds, is_container='container', yang_name="path-metric-bounds", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_affinities_values(self):
+ """
+ Getter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values (container)
+
+ YANG Description: Path affinities represented as values.
+ """
+ return self.__path_affinities_values
+
+ def _set_path_affinities_values(self, v, load=False):
+ """
+ Setter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_values() directly.
+
+ YANG Description: Path affinities represented as values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_values must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_affinities_values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_values(self):
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_affinity_names(self):
+ """
+ Getter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names (container)
+
+ YANG Description: Path affinities represented as names.
+ """
+ return self.__path_affinity_names
+
+ def _set_path_affinity_names(self, v, load=False):
+ """
+ Setter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_names() directly.
+
+ YANG Description: Path affinities represented as names.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_affinity_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_names(self):
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_srlgs_lists(self):
+ """
+ Getter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists (container)
+
+ YANG Description: Path SRLG properties container.
+ """
+ return self.__path_srlgs_lists
+
+ def _set_path_srlgs_lists(self, v, load=False):
+ """
+ Setter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_lists is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_lists() directly.
+
+ YANG Description: Path SRLG properties container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_lists must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_srlgs_lists = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_lists(self):
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_path_srlgs_names(self):
+ """
+ Getter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names (container)
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ return self.__path_srlgs_names
+
+ def _set_path_srlgs_names(self, v, load=False):
+ """
+ Setter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_names() directly.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__path_srlgs_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_names(self):
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_disjointness(self):
+ """
+ Getter method for disjointness, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/disjointness (te-path-disjointness)
+
+ YANG Description: The type of resource disjointness.
+When configured for a primary path, the disjointness level
+applies to all secondary LSPs. When configured for a
+secondary path, the disjointness level overrides the level
+configured for the primary path.
+ """
+ return self.__disjointness
+
+ def _set_disjointness(self, v, load=False):
+ """
+ Setter method for disjointness, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/disjointness (te-path-disjointness)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_disjointness is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_disjointness() directly.
+
+ YANG Description: The type of resource disjointness.
+When configured for a primary path, the disjointness level
+applies to all secondary LSPs. When configured for a
+secondary path, the disjointness level overrides the level
+configured for the primary path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """disjointness must be of a type compatible with te-path-disjointness""",
+ 'defined-type': "ietf-te-topology:te-path-disjointness",
+ 'generated-type': """YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)""",
+ })
+
+ self.__disjointness = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_disjointness(self):
+ self.__disjointness = YANGDynClass(base=YANGBitsType(allowed_bits={'node': '0', 'link': '1', 'srlg': '2'}), is_leaf=True, yang_name="disjointness", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-path-disjointness', is_config=True)
+
+ te_bandwidth = __builtin__.property(_get_te_bandwidth, _set_te_bandwidth)
+ link_protection = __builtin__.property(_get_link_protection, _set_link_protection)
+ setup_priority = __builtin__.property(_get_setup_priority, _set_setup_priority)
+ hold_priority = __builtin__.property(_get_hold_priority, _set_hold_priority)
+ signaling_type = __builtin__.property(_get_signaling_type, _set_signaling_type)
+ path_metric_bounds = __builtin__.property(_get_path_metric_bounds, _set_path_metric_bounds)
+ path_affinities_values = __builtin__.property(_get_path_affinities_values, _set_path_affinities_values)
+ path_affinity_names = __builtin__.property(_get_path_affinity_names, _set_path_affinity_names)
+ path_srlgs_lists = __builtin__.property(_get_path_srlgs_lists, _set_path_srlgs_lists)
+ path_srlgs_names = __builtin__.property(_get_path_srlgs_names, _set_path_srlgs_names)
+ disjointness = __builtin__.property(_get_disjointness, _set_disjointness)
+
+
+ _pyangbind_elements = OrderedDict([('te_bandwidth', te_bandwidth), ('link_protection', link_protection), ('setup_priority', setup_priority), ('hold_priority', hold_priority), ('signaling_type', signaling_type), ('path_metric_bounds', path_metric_bounds), ('path_affinities_values', path_affinities_values), ('path_affinity_names', path_affinity_names), ('path_srlgs_lists', path_srlgs_lists), ('path_srlgs_names', path_srlgs_names), ('disjointness', disjointness), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..9e3265c0729d76820783333b4db0fa0b49c60f46
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinities_value
+class path_affinities_values(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-affinities-values. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as values.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinities_value',)
+
+ _yang_name = 'path-affinities-values'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-affinities-values']
+
+ def _get_path_affinities_value(self):
+ """
+ Getter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/path_affinities_value (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinities_value
+
+ def _set_path_affinities_value(self, v, load=False):
+ """
+ Setter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/path_affinities_value (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_value() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_value must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_affinities_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_value(self):
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_affinities_value = __builtin__.property(_get_path_affinities_value, _set_path_affinities_value)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinities_value', path_affinities_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..8d6c0465d7071071b70e7292196d934bea81fe4f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_affinities_value(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-affinities-values/path-affinities-value. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__value',)
+
+ _yang_name = 'path-affinities-value'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-affinities-values', 'path-affinities-value']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/path_affinities_value/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/path_affinities_value/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/path_affinities_value/value (admin-groups)
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/path_affinities_value/value (admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with admin-groups""",
+ 'defined-type': "ietf-te-topology:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ value = __builtin__.property(_get_value, _set_value)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..93c042152835d0343828db33f1ccbdcc9fd0e712
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinity_name
+class path_affinity_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-affinity-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as names.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinity_name',)
+
+ _yang_name = 'path-affinity-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-affinity-names']
+
+ def _get_path_affinity_name(self):
+ """
+ Getter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinity_name
+
+ def _set_path_affinity_name(self, v, load=False):
+ """
+ Setter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_name() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_name(self):
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_affinity_name = __builtin__.property(_get_path_affinity_name, _set_path_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinity_name', path_affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..8f1e020959c1d9b22eeeaa6ca728765d5e967e0d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import affinity_name
+class path_affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-affinity-names/path-affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__affinity_name',)
+
+ _yang_name = 'path-affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-affinity-names', 'path-affinity-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_affinity_name(self):
+ """
+ Getter method for affinity_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/affinity_name (list)
+
+ YANG Description: List of named affinities.
+ """
+ return self.__affinity_name
+
+ def _set_affinity_name(self, v, load=False):
+ """
+ Setter method for affinity_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_affinity_name() directly.
+
+ YANG Description: List of named affinities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_affinity_name(self):
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ affinity_name = __builtin__.property(_get_affinity_name, _set_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('affinity_name', affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..84a532259c1bf948a93bf5e76256cc75a7159567
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-affinity-names/path-affinity-name/affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__name',)
+
+ _yang_name = 'affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-affinity-names', 'path-affinity-name', 'affinity-name']
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/affinity_name/name (string)
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/affinity_name/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ name = __builtin__.property(_get_name, _set_name)
+
+
+ _pyangbind_elements = OrderedDict([('name', name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..62154c4c0deac0a7b49e13cae45e760e872d0716
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_metric_bound
+class path_metric_bounds(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-metric-bounds. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric bounds container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_metric_bound',)
+
+ _yang_name = 'path-metric-bounds'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_metric_bound = YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-metric-bounds']
+
+ def _get_path_metric_bound(self):
+ """
+ Getter method for path_metric_bound, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/path_metric_bound (list)
+
+ YANG Description: List of TE path metric bounds.
+ """
+ return self.__path_metric_bound
+
+ def _set_path_metric_bound(self, v, load=False):
+ """
+ Setter method for path_metric_bound, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/path_metric_bound (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric_bound is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric_bound() directly.
+
+ YANG Description: List of TE path metric bounds.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric_bound must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_metric_bound = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric_bound(self):
+ self.__path_metric_bound = YANGDynClass(base=YANGListType("metric_type",path_metric_bound.path_metric_bound, yang_name="path-metric-bound", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_metric_bound = __builtin__.property(_get_path_metric_bound, _set_path_metric_bound)
+
+
+ _pyangbind_elements = OrderedDict([('path_metric_bound', path_metric_bound), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..61dd53dffe3102ad34f4a1a9db4ef7df9b306171
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,165 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_metric_bound(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-metric-bounds/path-metric-bound. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of TE path metric bounds.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__upper_bound',)
+
+ _yang_name = 'path-metric-bound'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__upper_bound = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-metric-bounds', 'path-metric-bound']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/path_metric_bound/metric_type (identityref)
+
+ YANG Description: Identifies an entry in the list of 'metric-type' items
+bound for the TE path.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/path_metric_bound/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies an entry in the list of 'metric-type' items
+bound for the TE path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_upper_bound(self):
+ """
+ Getter method for upper_bound, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/path_metric_bound/upper_bound (uint64)
+
+ YANG Description: Upper bound on the end-to-end TE path metric. A zero
+indicates an unbounded upper limit for the specific
+'metric-type'.
+ """
+ return self.__upper_bound
+
+ def _set_upper_bound(self, v, load=False):
+ """
+ Setter method for upper_bound, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/path_metric_bound/upper_bound (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_upper_bound is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_upper_bound() directly.
+
+ YANG Description: Upper bound on the end-to-end TE path metric. A zero
+indicates an unbounded upper limit for the specific
+'metric-type'.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """upper_bound must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__upper_bound = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_upper_bound(self):
+ self.__upper_bound = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), default=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64)(0), is_leaf=True, yang_name="upper-bound", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=True)
+
+ metric_type = __builtin__.property(_get_metric_type, _set_metric_type)
+ upper_bound = __builtin__.property(_get_upper_bound, _set_upper_bound)
+
+
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('upper_bound', upper_bound), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..28e1d8c74eba76ce3fbe5f1e38cffd564a78282d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_list
+class path_srlgs_lists(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-srlgs-lists. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path SRLG properties container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_list',)
+
+ _yang_name = 'path-srlgs-lists'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-srlgs-lists']
+
+ def _get_path_srlgs_list(self):
+ """
+ Getter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/path_srlgs_list (list)
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ return self.__path_srlgs_list
+
+ def _set_path_srlgs_list(self, v, load=False):
+ """
+ Setter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/path_srlgs_list (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_list() directly.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_list must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_srlgs_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_list(self):
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_srlgs_list = __builtin__.property(_get_path_srlgs_list, _set_path_srlgs_list)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_list', path_srlgs_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..a41c502dbcedab66dbdb30dcb749e9895d3f88b1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_list(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-srlgs-lists/path-srlgs-list. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__values',)
+
+ _yang_name = 'path-srlgs-list'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-srlgs-lists', 'path-srlgs-list']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/path_srlgs_list/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/path_srlgs_list/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_values(self):
+ """
+ Getter method for values, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/path_srlgs_list/values (srlg)
+
+ YANG Description: List of SRLG values.
+ """
+ return self.__values
+
+ def _set_values(self, v, load=False):
+ """
+ Setter method for values, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/path_srlgs_list/values (srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_values() directly.
+
+ YANG Description: List of SRLG values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """values must be of a type compatible with srlg""",
+ 'defined-type': "ietf-te-topology:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)""",
+ })
+
+ self.__values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_values(self):
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ values = __builtin__.property(_get_values, _set_values)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('values', values), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..964651c73accfe8a8e3076374aae9fe673844c9f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_name
+class path_srlgs_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-srlgs-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_name',)
+
+ _yang_name = 'path-srlgs-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-srlgs-names']
+
+ def _get_path_srlgs_name(self):
+ """
+ Getter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/path_srlgs_name (list)
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ return self.__path_srlgs_name
+
+ def _set_path_srlgs_name(self, v, load=False):
+ """
+ Setter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/path_srlgs_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_name() directly.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_srlgs_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_name(self):
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ path_srlgs_name = __builtin__.property(_get_path_srlgs_name, _set_path_srlgs_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_name', path_srlgs_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..2ae4647f9aecd4be075fa67d98d42765922081f9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/path-srlgs-names/path-srlgs-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__names',)
+
+ _yang_name = 'path-srlgs-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'path-srlgs-names', 'path-srlgs-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/path_srlgs_name/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/path_srlgs_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_names(self):
+ """
+ Getter method for names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/path_srlgs_name/names (string)
+
+ YANG Description: List of named SRLGs.
+ """
+ return self.__names
+
+ def _set_names(self, v, load=False):
+ """
+ Setter method for names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/path_srlgs_name/names (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_names() directly.
+
+ YANG Description: List of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """names must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_names(self):
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+ usage = __builtin__.property(_get_usage, _set_usage)
+ names = __builtin__.property(_get_names, _set_names)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('names', names), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..9d086807ab378b0c94eabdecbca9da35137aa8f6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/__init__.py
@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_bandwidth(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/te-bandwidth. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies TE bandwidth. The choices
+can be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__eth_bandwidth',)
+
+ _yang_name = 'te-bandwidth'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'te-bandwidth']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/generic (te-bandwidth)
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/generic (te-bandwidth)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: Bandwidth specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with te-bandwidth""",
+ 'defined-type': "ietf-te-topology:te-bandwidth",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+(,(0[xX](0((\\.0?)?[pP](\\+)?0?|(\\.0?))|1(\\.([\\da-fA-F]{0,5}[02468aAcCeE]?)?)?[pP](\\+)?(12[0-7]|1[01]\\d|0?\\d?\\d)?)|0[xX][\\da-fA-F]{1,8}|\\d+))*'}), is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-bandwidth', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn (container)
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_eth_bandwidth(self):
+ """
+ Getter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/eth_bandwidth (uint64)
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ return self.__eth_bandwidth
+
+ def _set_eth_bandwidth(self, v, load=False):
+ """
+ Setter method for eth_bandwidth, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/eth_bandwidth (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_eth_bandwidth is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_eth_bandwidth() directly.
+
+ YANG Description: Available bandwith value expressed in kilobits per second
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """eth_bandwidth must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)""",
+ })
+
+ self.__eth_bandwidth = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_eth_bandwidth(self):
+ self.__eth_bandwidth = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), restriction_dict={'range': ['0..10000000000']}), is_leaf=True, yang_name="eth-bandwidth", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='uint64', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ eth_bandwidth = __builtin__.property(_get_eth_bandwidth, _set_eth_bandwidth)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['eth_bandwidth']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('eth_bandwidth', eth_bandwidth), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8edd4ebde41cc7fdd55ac3ea16fc07871fd719dd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/__init__.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import odulist
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/te-bandwidth/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Bandwidth attributes for OTN links
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odulist','__odtu_flex_type',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'te-bandwidth', 'otn']
+
+ def _get_odulist(self):
+ """
+ Getter method for odulist, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist (list)
+
+ YANG Description: OTN bandwidth definition
+ """
+ return self.__odulist
+
+ def _set_odulist(self, v, load=False):
+ """
+ Setter method for odulist, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odulist is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odulist() directly.
+
+ YANG Description: OTN bandwidth definition
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odulist must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__odulist = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odulist(self):
+ self.__odulist = YANGDynClass(base=YANGListType("odu_type",odulist.odulist, yang_name="odulist", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='odu-type', extensions=None, choice=('technology', 'otn')), is_container='list', yang_name="odulist", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='list', is_config=True)
+
+
+ def _get_odtu_flex_type(self):
+ """
+ Getter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+set up along the underlay path of this OTN Local
+Link Connectivyt entry.
+ """
+ return self.__odtu_flex_type
+
+ def _set_odtu_flex_type(self, v, load=False):
+ """
+ Setter method for odtu_flex_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odtu_flex_type (l1-types:odtu-flex-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odtu_flex_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odtu_flex_type() directly.
+
+ YANG Description: The type of Optical Data Tributary Unit (ODTU)
+whose nominal bitrate is used to compute the number of
+Tributary Slots (TS) required by the ODUflex LSPs
+set up along the underlay path of this OTN Local
+Link Connectivyt entry.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odtu_flex_type must be of a type compatible with l1-types:odtu-flex-type""",
+ 'defined-type': "l1-types:odtu-flex-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)""",
+ })
+
+ self.__odtu_flex_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odtu_flex_type(self):
+ self.__odtu_flex_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'2': {}, '3': {}, '4': {}, 'Cn': {}},), is_leaf=True, yang_name="odtu-flex-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='l1-types:odtu-flex-type', is_config=True)
+
+ odulist = __builtin__.property(_get_odulist, _set_odulist)
+ odtu_flex_type = __builtin__.property(_get_odtu_flex_type, _set_odtu_flex_type)
+
+ __choices__ = {'technology': {'otn': ['odulist', 'odtu_flex_type']}}
+ _pyangbind_elements = OrderedDict([('odulist', odulist), ('odtu_flex_type', odtu_flex_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..22a8a8f859f7c787bcf6899bdb2887fbadce9d62
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist/__init__.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class odulist(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-constraints/te-bandwidth/otn/odulist. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: OTN bandwidth definition
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__odu_type','__number','__ts_number',)
+
+ _yang_name = 'odulist'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-constraints', 'te-bandwidth', 'otn', 'odulist']
+
+ def _get_odu_type(self):
+ """
+ Getter method for odu_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist/odu_type (identityref)
+
+ YANG Description: ODU type
+ """
+ return self.__odu_type
+
+ def _set_odu_type(self, v, load=False):
+ """
+ Setter method for odu_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist/odu_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_odu_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_odu_type() directly.
+
+ YANG Description: ODU type
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """odu_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__odu_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_odu_type(self):
+ self.__odu_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU0': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU1': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU2e': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU3': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODU4': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:ODUflex-resizable': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="odu-type", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_number(self):
+ """
+ Getter method for number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist/number (uint16)
+
+ YANG Description: Number of ODUs
+ """
+ return self.__number
+
+ def _set_number(self, v, load=False):
+ """
+ Setter method for number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist/number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_number() directly.
+
+ YANG Description: Number of ODUs
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_number(self):
+ self.__number = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+
+ def _get_ts_number(self):
+ """
+ Getter method for ts_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist/ts_number (uint16)
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ return self.__ts_number
+
+ def _set_ts_number(self, v, load=False):
+ """
+ Setter method for ts_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/otn/odulist/ts_number (uint16)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_number() directly.
+
+ YANG Description: The number of Tributary Slots (TS) that
+could be used by all the ODUflex LSPs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_number must be of a type compatible with uint16""",
+ 'defined-type': "uint16",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)""",
+ })
+
+ self.__ts_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_number(self):
+ self.__ts_number = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="ts-number", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='uint16', is_config=True)
+
+ odu_type = __builtin__.property(_get_odu_type, _set_odu_type)
+ number = __builtin__.property(_get_number, _set_number)
+ ts_number = __builtin__.property(_get_ts_number, _set_ts_number)
+
+ __choices__ = {'technology': {'otn': ['odu_type', 'number', 'ts_number']}}
+ _pyangbind_elements = OrderedDict([('odu_type', odu_type), ('number', number), ('ts_number', ts_number), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d881474f2984fc4af3230caa846eb05d5a6342a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/__init__.py
@@ -0,0 +1,318 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_metric
+from . import path_affinities_values
+from . import path_affinity_names
+from . import path_srlgs_lists
+from . import path_srlgs_names
+from . import path_route_objects
+class path_properties(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The TE path properties.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_metric','__path_affinities_values','__path_affinity_names','__path_srlgs_lists','__path_srlgs_names','__path_route_objects',)
+
+ _yang_name = 'path-properties'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_metric = YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__path_route_objects = YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties']
+
+ def _get_path_metric(self):
+ """
+ Getter method for path_metric, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__path_metric
+
+ def _set_path_metric(self, v, load=False):
+ """
+ Setter method for path_metric, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_metric(self):
+ self.__path_metric = YANGDynClass(base=YANGListType("metric_type",path_metric.path_metric, yang_name="path-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None), is_container='list', yang_name="path-metric", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+
+ def _get_path_affinities_values(self):
+ """
+ Getter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values (container)
+
+ YANG Description: Path affinities represented as values.
+ """
+ return self.__path_affinities_values
+
+ def _set_path_affinities_values(self, v, load=False):
+ """
+ Setter method for path_affinities_values, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_values() directly.
+
+ YANG Description: Path affinities represented as values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_values must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinities_values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_values(self):
+ self.__path_affinities_values = YANGDynClass(base=path_affinities_values.path_affinities_values, is_container='container', yang_name="path-affinities-values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_affinity_names(self):
+ """
+ Getter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names (container)
+
+ YANG Description: Path affinities represented as names.
+ """
+ return self.__path_affinity_names
+
+ def _set_path_affinity_names(self, v, load=False):
+ """
+ Setter method for path_affinity_names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_names() directly.
+
+ YANG Description: Path affinities represented as names.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_affinity_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_names(self):
+ self.__path_affinity_names = YANGDynClass(base=path_affinity_names.path_affinity_names, is_container='container', yang_name="path-affinity-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_lists(self):
+ """
+ Getter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists (container)
+
+ YANG Description: Path SRLG properties container.
+ """
+ return self.__path_srlgs_lists
+
+ def _set_path_srlgs_lists(self, v, load=False):
+ """
+ Setter method for path_srlgs_lists, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_lists is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_lists() directly.
+
+ YANG Description: Path SRLG properties container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_lists must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_lists = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_lists(self):
+ self.__path_srlgs_lists = YANGDynClass(base=path_srlgs_lists.path_srlgs_lists, is_container='container', yang_name="path-srlgs-lists", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_srlgs_names(self):
+ """
+ Getter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names (container)
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ return self.__path_srlgs_names
+
+ def _set_path_srlgs_names(self, v, load=False):
+ """
+ Setter method for path_srlgs_names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_names() directly.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_names must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_srlgs_names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_names(self):
+ self.__path_srlgs_names = YANGDynClass(base=path_srlgs_names.path_srlgs_names, is_container='container', yang_name="path-srlgs-names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_path_route_objects(self):
+ """
+ Getter method for path_route_objects, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects (container)
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ return self.__path_route_objects
+
+ def _set_path_route_objects(self, v, load=False):
+ """
+ Setter method for path_route_objects, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_route_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_route_objects() directly.
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_route_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__path_route_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_route_objects(self):
+ self.__path_route_objects = YANGDynClass(base=path_route_objects.path_route_objects, is_container='container', yang_name="path-route-objects", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ path_metric = __builtin__.property(_get_path_metric)
+ path_affinities_values = __builtin__.property(_get_path_affinities_values)
+ path_affinity_names = __builtin__.property(_get_path_affinity_names)
+ path_srlgs_lists = __builtin__.property(_get_path_srlgs_lists)
+ path_srlgs_names = __builtin__.property(_get_path_srlgs_names)
+ path_route_objects = __builtin__.property(_get_path_route_objects)
+
+
+ _pyangbind_elements = OrderedDict([('path_metric', path_metric), ('path_affinities_values', path_affinities_values), ('path_affinity_names', path_affinity_names), ('path_srlgs_lists', path_srlgs_lists), ('path_srlgs_names', path_srlgs_names), ('path_route_objects', path_route_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..3384b6a42e7ed530221f3ea1505e999fdefb73db
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinities_value
+class path_affinities_values(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-affinities-values. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as values.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinities_value',)
+
+ _yang_name = 'path-affinities-values'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-affinities-values']
+
+ def _get_path_affinities_value(self):
+ """
+ Getter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/path_affinities_value (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinities_value
+
+ def _set_path_affinities_value(self, v, load=False):
+ """
+ Setter method for path_affinities_value, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/path_affinities_value (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinities_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinities_value() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinities_value must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinities_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinities_value(self):
+ self.__path_affinities_value = YANGDynClass(base=YANGListType("usage",path_affinities_value.path_affinities_value, yang_name="path-affinities-value", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinities-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinities_value = __builtin__.property(_get_path_affinities_value)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinities_value', path_affinities_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..626f7d24037391d083bb55c1b9135783954c867d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_affinities_value(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-affinities-values/path-affinities-value. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__value',)
+
+ _yang_name = 'path-affinities-value'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-affinities-values', 'path-affinities-value']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/path_affinities_value/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/path_affinities_value/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of value affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_value(self):
+ """
+ Getter method for value, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/path_affinities_value/value (admin-groups)
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ return self.__value
+
+ def _set_value(self, v, load=False):
+ """
+ Setter method for value, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/path_affinities_value/value (admin-groups)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_value() directly.
+
+ YANG Description: The affinity value. The default is empty.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """value must be of a type compatible with admin-groups""",
+ 'defined-type': "ietf-te-topology:admin-groups",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)""",
+ })
+
+ self.__value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_value(self):
+ self.__value = YANGDynClass(base=[RestrictedClassType(base_type=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}), restriction_dict={'length': ['1..11']}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'}),], default=six.text_type(""), is_leaf=True, yang_name="value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='admin-groups', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ value = __builtin__.property(_get_value)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('value', value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..3fc26577e1b13b6bee6537f99d5be9369fd3f3c6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_affinity_name
+class path_affinity_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-affinity-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path affinities represented as names.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_affinity_name',)
+
+ _yang_name = 'path-affinity-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-affinity-names']
+
+ def _get_path_affinity_name(self):
+ """
+ Getter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name (list)
+
+ YANG Description: List of named affinity constraints.
+ """
+ return self.__path_affinity_name
+
+ def _set_path_affinity_name(self, v, load=False):
+ """
+ Setter method for path_affinity_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_affinity_name() directly.
+
+ YANG Description: List of named affinity constraints.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_affinity_name(self):
+ self.__path_affinity_name = YANGDynClass(base=YANGListType("usage",path_affinity_name.path_affinity_name, yang_name="path-affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_affinity_name = __builtin__.property(_get_path_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_affinity_name', path_affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..63035d44dd3fdd4b30b37bd16b316b8f90e31b0b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,162 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import affinity_name
+class path_affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-affinity-names/path-affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinity constraints.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__affinity_name',)
+
+ _yang_name = 'path-affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-affinity-names', 'path-affinity-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/usage (identityref)
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in the list of named affinity
+constraints.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-all': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-include-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:resource-aff-exclude-any': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_affinity_name(self):
+ """
+ Getter method for affinity_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/affinity_name (list)
+
+ YANG Description: List of named affinities.
+ """
+ return self.__affinity_name
+
+ def _set_affinity_name(self, v, load=False):
+ """
+ Setter method for affinity_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/affinity_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_affinity_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_affinity_name() directly.
+
+ YANG Description: List of named affinities.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """affinity_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__affinity_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_affinity_name(self):
+ self.__affinity_name = YANGDynClass(base=YANGListType("name",affinity_name.affinity_name, yang_name="affinity-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='name', extensions=None), is_container='list', yang_name="affinity-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ affinity_name = __builtin__.property(_get_affinity_name)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('affinity_name', affinity_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..42383ee4d247fdfb6b351fad04628e72db2022e3
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,120 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class affinity_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-affinity-names/path-affinity-name/affinity-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named affinities.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__name',)
+
+ _yang_name = 'affinity-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-affinity-names', 'path-affinity-name', 'affinity-name']
+
+ def _get_name(self):
+ """
+ Getter method for name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/affinity_name/name (string)
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ return self.__name
+
+ def _set_name(self, v, load=False):
+ """
+ Setter method for name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/affinity_name/name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_name() directly.
+
+ YANG Description: Identifies a named affinity entry.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_name(self):
+ self.__name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ name = __builtin__.property(_get_name)
+
+
+ _pyangbind_elements = OrderedDict([('name', name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..5a283282dbd0921574717dd049ba6ec7cdc435f2
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric/__init__.py
@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__accumulative_value',)
+
+ _yang_name = 'path-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__accumulative_value = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric/metric_type (identityref)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: TE path metric type.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_accumulative_value(self):
+ """
+ Getter method for accumulative_value, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric/accumulative_value (uint64)
+
+ YANG Description: TE path metric accumulative value.
+ """
+ return self.__accumulative_value
+
+ def _set_accumulative_value(self, v, load=False):
+ """
+ Setter method for accumulative_value, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric/accumulative_value (uint64)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_accumulative_value is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_accumulative_value() directly.
+
+ YANG Description: TE path metric accumulative value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """accumulative_value must be of a type compatible with uint64""",
+ 'defined-type': "uint64",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)""",
+ })
+
+ self.__accumulative_value = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_accumulative_value(self):
+ self.__accumulative_value = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..18446744073709551615']}, int_size=64), is_leaf=True, yang_name="accumulative-value", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint64', is_config=False)
+
+ metric_type = __builtin__.property(_get_metric_type)
+ accumulative_value = __builtin__.property(_get_accumulative_value)
+
+
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('accumulative_value', accumulative_value), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..425ac19d0ba2ad2089694efa68733b4a4df87be9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/__init__.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_route_object
+class path_route_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-route-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of route objects either returned by
+the computation engine or actually used by an LSP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_route_object',)
+
+ _yang_name = 'path-route-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_route_object = YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-route-objects']
+
+ def _get_path_route_object(self):
+ """
+ Getter method for path_route_object, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object (list)
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ return self.__path_route_object
+
+ def _set_path_route_object(self, v, load=False):
+ """
+ Setter method for path_route_object, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_route_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_route_object() directly.
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_route_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_route_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_route_object(self):
+ self.__path_route_object = YANGDynClass(base=YANGListType("index",path_route_object.path_route_object, yang_name="path-route-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="path-route-object", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_route_object = __builtin__.property(_get_path_route_object)
+
+
+ _pyangbind_elements = OrderedDict([('path_route_object', path_route_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..abb7aee29bfcff96c141252b8b576eee2bc77580
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,327 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_route_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-route-objects/path-route-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of route objects either returned by the computation
+engine or actually used by an LSP.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-route-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-route-objects', 'path-route-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key
+values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key
+values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=False)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ index = __builtin__.property(_get_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3d293b8351e545985c03b1d6932795428635e61
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-route-objects/path-route-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-route-objects', 'path-route-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ as_number = __builtin__.property(_get_as_number)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..10f4a55b7ebcaf51bc5be227c28139119e9638e6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-route-objects/path-route-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=False)
+
+ te_label = __builtin__.property(_get_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8764e4794ccf6b384a53d66c77dc2fd17bd202ea
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-route-objects/path-route-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=False)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=False)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=False)
+
+ generic = __builtin__.property(_get_generic)
+ otn = __builtin__.property(_get_otn)
+ vlanid = __builtin__.property(_get_vlanid)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..25a5ec822fcb142ca575a1d09946fd504aac40aa
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-route-objects/path-route-object/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-route-objects', 'path-route-object', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=False)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=False)
+
+ tpn = __builtin__.property(_get_tpn)
+ tsg = __builtin__.property(_get_tsg)
+ ts_list = __builtin__.property(_get_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f9882c112f2d67c83372e89ba435e131f90edaa
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-route-objects/path-route-object/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-route-objects', 'path-route-object', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c406a2f54e28223ea024680f6781b5cf5bd44eb1
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-route-objects/path-route-object/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-route-objects', 'path-route-object', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c965f3ce1f85c93f8af1465d77cd6ae33b014c1b
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-route-objects/path-route-object/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-route-objects', 'path-route-object', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=False)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=False)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=False)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=False)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id)
+ node_id = __builtin__.property(_get_node_id)
+ hop_type = __builtin__.property(_get_hop_type)
+ direction = __builtin__.property(_get_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..db6b557eb1491d21d65f67be69d642a0fb956024
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_list
+class path_srlgs_lists(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-srlgs-lists. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Path SRLG properties container.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_list',)
+
+ _yang_name = 'path-srlgs-lists'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-srlgs-lists']
+
+ def _get_path_srlgs_list(self):
+ """
+ Getter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/path_srlgs_list (list)
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ return self.__path_srlgs_list
+
+ def _set_path_srlgs_list(self, v, load=False):
+ """
+ Setter method for path_srlgs_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/path_srlgs_list (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_list() directly.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_list must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_list(self):
+ self.__path_srlgs_list = YANGDynClass(base=YANGListType("usage",path_srlgs_list.path_srlgs_list, yang_name="path-srlgs-list", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-list", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_list = __builtin__.property(_get_path_srlgs_list)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_list', path_srlgs_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..909764a6d1e8e0bfe61d9044d8e85d8cc4cb9c8c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_list(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-srlgs-lists/path-srlgs-list. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of SRLG values to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__values',)
+
+ _yang_name = 'path-srlgs-list'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-srlgs-lists', 'path-srlgs-list']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/path_srlgs_list/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/path_srlgs_list/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_values(self):
+ """
+ Getter method for values, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/path_srlgs_list/values (srlg)
+
+ YANG Description: List of SRLG values.
+ """
+ return self.__values
+
+ def _set_values(self, v, load=False):
+ """
+ Setter method for values, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/path_srlgs_list/values (srlg)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_values is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_values() directly.
+
+ YANG Description: List of SRLG values.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """values must be of a type compatible with srlg""",
+ 'defined-type': "ietf-te-topology:srlg",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)""",
+ })
+
+ self.__values = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_values(self):
+ self.__values = YANGDynClass(unique=True, base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32)), is_leaf=False, yang_name="values", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='srlg', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ values = __builtin__.property(_get_values)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('values', values), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..7466c4918dd186ed92cf52f6c3d00637e7136d51
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_srlgs_name
+class path_srlgs_names(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-srlgs-names. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the list of named SRLGs.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_srlgs_name',)
+
+ _yang_name = 'path-srlgs-names'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-srlgs-names']
+
+ def _get_path_srlgs_name(self):
+ """
+ Getter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/path_srlgs_name (list)
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ return self.__path_srlgs_name
+
+ def _set_path_srlgs_name(self, v, load=False):
+ """
+ Setter method for path_srlgs_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/path_srlgs_name (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_srlgs_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_srlgs_name() directly.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_srlgs_name must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)""",
+ })
+
+ self.__path_srlgs_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_srlgs_name(self):
+ self.__path_srlgs_name = YANGDynClass(base=YANGListType("usage",path_srlgs_name.path_srlgs_name, yang_name="path-srlgs-name", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='usage', extensions=None), is_container='list', yang_name="path-srlgs-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=False)
+
+ path_srlgs_name = __builtin__.property(_get_path_srlgs_name)
+
+
+ _pyangbind_elements = OrderedDict([('path_srlgs_name', path_srlgs_name), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/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/nbi/service/rest_server/nbi_plugins/ietf_network/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..75f5ea586d436c798808c15cdc57103ac2b73953
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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,161 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class path_srlgs_name(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/path-properties/path-srlgs-names/path-srlgs-name. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of named SRLGs to be included or excluded.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__usage','__names',)
+
+ _yang_name = 'path-srlgs-name'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'path-properties', 'path-srlgs-names', 'path-srlgs-name']
+
+ def _get_usage(self):
+ """
+ Getter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/path_srlgs_name/usage (identityref)
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ return self.__usage
+
+ def _set_usage(self, v, load=False):
+ """
+ Setter method for usage, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/path_srlgs_name/usage (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_usage is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_usage() directly.
+
+ YANG Description: Identifies an entry in a list of named SRLGs to either
+include or exclude.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """usage must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)""",
+ })
+
+ self.__usage = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_usage(self):
+ self.__usage = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-include-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-object': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:route-exclude-srlg': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="usage", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=False)
+
+
+ def _get_names(self):
+ """
+ Getter method for names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/path_srlgs_name/names (string)
+
+ YANG Description: List of named SRLGs.
+ """
+ return self.__names
+
+ def _set_names(self, v, load=False):
+ """
+ Setter method for names, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/path_srlgs_name/names (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_names is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_names() directly.
+
+ YANG Description: List of named SRLGs.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """names must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)""",
+ })
+
+ self.__names = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_names(self):
+ self.__names = YANGDynClass(unique=True, base=TypedListType(allowed_type=six.text_type), is_leaf=False, yang_name="names", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=False)
+
+ usage = __builtin__.property(_get_usage)
+ names = __builtin__.property(_get_names)
+
+
+ _pyangbind_elements = OrderedDict([('usage', usage), ('names', names), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4c8bb6d3b582017cb7ac23a67e8b788a412e646
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/__init__.py
@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import primary_path
+from . import backup_path
+from . import tunnel_termination_points
+from . import tunnels
+class underlay(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Attributes of the TE link underlay.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__enabled','__primary_path','__backup_path','__protection_type','__tunnel_termination_points','__tunnels',)
+
+ _yang_name = 'underlay'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay']
+
+ def _get_enabled(self):
+ """
+ Getter method for enabled, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/enabled (boolean)
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ return self.__enabled
+
+ def _set_enabled(self, v, load=False):
+ """
+ Setter method for enabled, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/enabled (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_enabled is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_enabled() directly.
+
+ YANG Description: 'true' if the underlay is enabled.
+'false' if the underlay is disabled.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """enabled must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__enabled = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_enabled(self):
+ self.__enabled = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="enabled", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_primary_path(self):
+ """
+ Getter method for primary_path, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path (container)
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ return self.__primary_path
+
+ def _set_primary_path(self, v, load=False):
+ """
+ Setter method for primary_path, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_primary_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_primary_path() directly.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """primary_path must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__primary_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_primary_path(self):
+ self.__primary_path = YANGDynClass(base=primary_path.primary_path, is_container='container', yang_name="primary-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_backup_path(self):
+ """
+ Getter method for backup_path, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path (list)
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ return self.__backup_path
+
+ def _set_backup_path(self, v, load=False):
+ """
+ Setter method for backup_path, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_backup_path is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_backup_path() directly.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """backup_path must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__backup_path = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_backup_path(self):
+ self.__backup_path = YANGDynClass(base=YANGListType("index",backup_path.backup_path, yang_name="backup-path", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='index', extensions=None), is_container='list', yang_name="backup-path", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+
+ def _get_protection_type(self):
+ """
+ Getter method for protection_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/protection_type (identityref)
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ return self.__protection_type
+
+ def _set_protection_type(self, v, load=False):
+ """
+ Setter method for protection_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/protection_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_protection_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_protection_type() directly.
+
+ YANG Description: Underlay protection type desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """protection_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__protection_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_protection_type(self):
+ self.__protection_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unprotected': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute-extra': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-reroute': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-n': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-1-for-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-unidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-bidir-1-plus-1': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:lsp-protection-extra-traffic': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="protection-type", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_tunnel_termination_points(self):
+ """
+ Getter method for tunnel_termination_points, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points (container)
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ return self.__tunnel_termination_points
+
+ def _set_tunnel_termination_points(self, v, load=False):
+ """
+ Setter method for tunnel_termination_points, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_termination_points is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_termination_points() directly.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_termination_points must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tunnel_termination_points = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_termination_points(self):
+ self.__tunnel_termination_points = YANGDynClass(base=tunnel_termination_points.tunnel_termination_points, is_container='container', yang_name="tunnel-termination-points", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_tunnels(self):
+ """
+ Getter method for tunnels, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels (container)
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ return self.__tunnels
+
+ def _set_tunnels(self, v, load=False):
+ """
+ Setter method for tunnels, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnels is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnels() directly.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnels must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tunnels = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnels(self):
+ self.__tunnels = YANGDynClass(base=tunnels.tunnels, is_container='container', yang_name="tunnels", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ enabled = __builtin__.property(_get_enabled, _set_enabled)
+ primary_path = __builtin__.property(_get_primary_path, _set_primary_path)
+ backup_path = __builtin__.property(_get_backup_path, _set_backup_path)
+ protection_type = __builtin__.property(_get_protection_type, _set_protection_type)
+ tunnel_termination_points = __builtin__.property(_get_tunnel_termination_points, _set_tunnel_termination_points)
+ tunnels = __builtin__.property(_get_tunnels, _set_tunnels)
+
+
+ _pyangbind_elements = OrderedDict([('enabled', enabled), ('primary_path', primary_path), ('backup_path', backup_path), ('protection_type', protection_type), ('tunnel_termination_points', tunnel_termination_points), ('tunnels', tunnels), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..f9690f9383c3ec5d4f013e28890f2ad02df14d7c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/__init__.py
@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class backup_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/backup-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of backup service paths on the underlay topology that
+protect the underlay primary path. If the primary path is
+not protected, the list contains zero elements. If the
+primary path is protected, the list contains one or more
+elements.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__network_ref','__path_element',)
+
+ _yang_name = 'backup-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'backup-path']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/index (uint32)
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: A sequence number to identify a backup path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element (list)
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ path_element = __builtin__.property(_get_path_element, _set_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('index', index), ('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..beb298aa14f672bc2a0bf46ff0ebcb7b47005f77
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/__init__.py
@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/backup-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the backup service
+path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'backup-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ path_element_id = __builtin__.property(_get_path_element_id, _set_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..60abe510bdcf78892f0a9a2f9f0e2a682f790fbb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/backup-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'backup-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ee2330a9e0c326a26439c365c98bbf212319529
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/backup-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'backup-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..94d9603a099b262137aa19b7b22e885364b94a38
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/backup-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3dfbe742aaf061e6d11ab2e8959e42f0275caadf
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/backup-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'backup-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9b3a906d14e0b0fec0cec35d7266587e142330a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/backup-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'backup-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4e4080396d83fca58c1a2f30fc6d33a9e3c27ed
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/backup-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'backup-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..274e9473a569e845f1e2cabb879a4b9ad169e065
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/backup-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'backup-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..56854b5857837e5cab85b13189ed10916c1438e6
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/__init__.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import path_element
+class primary_path(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/primary-path. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The service path on the underlay topology that
+supports this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__network_ref','__path_element',)
+
+ _yang_name = 'primary-path'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'primary-path']
+
+ def _get_network_ref(self):
+ """
+ Getter method for network_ref, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/network_ref (leafref)
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ return self.__network_ref
+
+ def _set_network_ref(self, v, load=False):
+ """
+ Setter method for network_ref, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/network_ref (leafref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_network_ref is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_network_ref() directly.
+
+ YANG Description: Used to reference a network -- for example, an underlay
+network.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """network_ref must be of a type compatible with leafref""",
+ 'defined-type': "leafref",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)""",
+ })
+
+ self.__network_ref = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_network_ref(self):
+ self.__network_ref = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="network-ref", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='leafref', is_config=True)
+
+
+ def _get_path_element(self):
+ """
+ Getter method for path_element, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element (list)
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ return self.__path_element
+
+ def _set_path_element(self, v, load=False):
+ """
+ Setter method for path_element, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element() directly.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__path_element = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element(self):
+ self.__path_element = YANGDynClass(base=YANGListType("path_element_id",path_element.path_element, yang_name="path-element", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='path-element-id', extensions=None), is_container='list', yang_name="path-element", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ network_ref = __builtin__.property(_get_network_ref, _set_network_ref)
+ path_element = __builtin__.property(_get_path_element, _set_path_element)
+
+
+ _pyangbind_elements = OrderedDict([('network_ref', network_ref), ('path_element', path_element), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..f54312b46f7a07411770ee27ee1f360b82c2b9d9
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/__init__.py
@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+class path_element(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/primary-path/path-element. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: A list of path elements describing the service path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__path_element_id','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop',)
+
+ _yang_name = 'path-element'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'primary-path', 'path-element']
+
+ def _get_path_element_id(self):
+ """
+ Getter method for path_element_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/path_element_id (uint32)
+
+ YANG Description: To identify the element in a path.
+ """
+ return self.__path_element_id
+
+ def _set_path_element_id(self, v, load=False):
+ """
+ Setter method for path_element_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/path_element_id (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_path_element_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_path_element_id() directly.
+
+ YANG Description: To identify the element in a path.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """path_element_id must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__path_element_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_path_element_id(self):
+ self.__path_element_id = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="path-element-id", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ path_element_id = __builtin__.property(_get_path_element_id, _set_path_element_id)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+
+ __choices__ = {'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop']}}
+ _pyangbind_elements = OrderedDict([('path_element_id', path_element_id), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..013370a26795f61d508e086d2eb10ec61207d3ae
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/primary-path/path-element/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'primary-path', 'path-element', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f048ca63252d00b5550a102c254ac3970806d7a
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/primary-path/path-element/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'primary-path', 'path-element', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..345fd6279609dfb0ceb951b29996de73856cc0cb
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/primary-path/path-element/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label']
+
+ def _get_generic(self):
+ """
+ Getter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+
+ YANG Description: TE label specified in a generic format.
+ """
+ return self.__generic
+
+ def _set_generic(self, v, load=False):
+ """
+ Setter method for generic, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/generic (rt-types:generalized-label)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_generic is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_generic() directly.
+
+ YANG Description: TE label specified in a generic format.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """generic must be of a type compatible with rt-types:generalized-label""",
+ 'defined-type': "rt-types:generalized-label",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)""",
+ })
+
+ self.__generic = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_generic(self):
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+
+
+ def _get_otn(self):
+ """
+ Getter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+
+ YANG Description: Label hop for OTN.
+ """
+ return self.__otn
+
+ def _set_otn(self, v, load=False):
+ """
+ Setter method for otn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_otn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_otn() directly.
+
+ YANG Description: Label hop for OTN.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """otn must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__otn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_otn(self):
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+
+
+ def _get_vlanid(self):
+ """
+ Getter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+
+ YANG Description: VLAN tag id.
+ """
+ return self.__vlanid
+
+ def _set_vlanid(self, v, load=False):
+ """
+ Setter method for vlanid, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/vlanid (etht-types:vlanid)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_vlanid is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_vlanid() directly.
+
+ YANG Description: VLAN tag id.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """vlanid must be of a type compatible with etht-types:vlanid""",
+ 'defined-type': "etht-types:vlanid",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)""",
+ })
+
+ self.__vlanid = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_vlanid(self):
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+
+ YANG Description: Label direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/direction (te-label-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Label direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-label-direction""",
+ 'defined-type': "ietf-te-topology:te-label-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ generic = __builtin__.property(_get_generic, _set_generic)
+ otn = __builtin__.property(_get_otn, _set_otn)
+ vlanid = __builtin__.property(_get_vlanid, _set_vlanid)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'technology': {'generic': ['generic'], 'otn': ['otn'], 'eth': ['vlanid']}, 'type': {'label': ['direction']}}
+ _pyangbind_elements = OrderedDict([('generic', generic), ('otn', otn), ('vlanid', vlanid), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..453fa07179533dcb2a64017fd255b526f929442f
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn/__init__.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class otn(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/primary-path/path-element/label-hop/te-label/otn. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop for OTN.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tpn','__tsg','__ts_list',)
+
+ _yang_name = 'otn'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'primary-path', 'path-element', 'label-hop', 'te-label', 'otn']
+
+ def _get_tpn(self):
+ """
+ Getter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ return self.__tpn
+
+ def _set_tpn(self, v, load=False):
+ """
+ Setter method for tpn, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn/tpn (otn-tpn)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tpn is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tpn() directly.
+
+ YANG Description: Tributary Port Number (TPN).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tpn must be of a type compatible with otn-tpn""",
+ 'defined-type': "ietf-otn-topology:otn-tpn",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)""",
+ })
+
+ self.__tpn = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tpn(self):
+ self.__tpn = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4095']}), is_leaf=True, yang_name="tpn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='otn-tpn', is_config=True)
+
+
+ def _get_tsg(self):
+ """
+ Getter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ return self.__tsg
+
+ def _set_tsg(self, v, load=False):
+ """
+ Setter method for tsg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn/tsg (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tsg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tsg() directly.
+
+ YANG Description: Tributary Slot Granularity (TSG).
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tsg must be of a type compatible with identityref""",
+ 'defined-type': "ietf-otn-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__tsg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tsg(self):
+ self.__tsg = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-1.25G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-2.5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'ietf-layer1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}, 'l1-types:tsg-5G': {'@module': 'ietf-layer1-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-layer1-types'}},), is_leaf=True, yang_name="tsg", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_ts_list(self):
+ """
+ Getter method for ts_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ return self.__ts_list
+
+ def _set_ts_list(self, v, load=False):
+ """
+ Setter method for ts_list, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/label_hop/te_label/otn/ts_list (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_ts_list is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_ts_list() directly.
+
+ YANG Description: A list of available Tributary Slots (TS) ranging
+
+
+
+
+between 1 and 4095. If multiple values or
+ranges are given, they all MUST be disjoint
+and MUST be in ascending order.
+For example 1-20,25,50-1000.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """ts_list must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__ts_list = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_ts_list(self):
+ self.__ts_list = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '([1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?(,[1-9][0-9]{0,3}(-[1-9][0-9]{0,3})?)*)'}), is_leaf=True, yang_name="ts-list", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='string', is_config=True)
+
+ tpn = __builtin__.property(_get_tpn, _set_tpn)
+ tsg = __builtin__.property(_get_tsg, _set_tsg)
+ ts_list = __builtin__.property(_get_ts_list, _set_ts_list)
+
+ __choices__ = {'technology': {'otn': ['tpn', 'tsg', 'ts_list']}}
+ _pyangbind_elements = OrderedDict([('tpn', tpn), ('tsg', tsg), ('ts_list', ts_list), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e222d4341ea9807e87a41d694ce1fddf93874ee
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop/__init__.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/primary-path/path-element/numbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__hop_type','__direction',)
+
+ _yang_name = 'numbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'primary-path', 'path-element', 'numbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE Link Termination Point (LTP) identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'numbered-link-hop': ['link_tp_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_node_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_node_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fdc5c17286825e797e93cb16dabec136e84ba130
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_node_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class numbered_node_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/primary-path/path-element/numbered-node-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Numbered node route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__node_id','__hop_type',)
+
+ _yang_name = 'numbered-node-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'primary-path', 'path-element', 'numbered-node-hop']
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_node_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/numbered_node_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'numbered-node-hop': ['node_id', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('node_id', node_id), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f41ade4f487d23a00cee5856b9509b64fc00fe5
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/__init__.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class unnumbered_link_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/primary-path/path-element/unnumbered-link-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__link_tp_id','__node_id','__hop_type','__direction',)
+
+ _yang_name = 'unnumbered-link-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'primary-path', 'path-element', 'unnumbered-link-hop']
+
+ def _get_link_tp_id(self):
+ """
+ Getter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ return self.__link_tp_id
+
+ def _set_link_tp_id(self, v, load=False):
+ """
+ Setter method for link_tp_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/link_tp_id (te-tp-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_link_tp_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_link_tp_id() directly.
+
+ YANG Description: TE LTP identifier. The combination of the TE link ID
+and the TE node ID is used to identify an unnumbered
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """link_tp_id must be of a type compatible with te-tp-id""",
+ 'defined-type': "ietf-te-topology:te-tp-id",
+ 'generated-type': """YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)""",
+ })
+
+ self.__link_tp_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_link_tp_id(self):
+ self.__link_tp_id = YANGDynClass(base=[RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\\p{N}\\p{L}]+)?'}),RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\\p{N}\\p{L}]+)?'}),], is_leaf=True, yang_name="link-tp-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-tp-id', is_config=True)
+
+
+ def _get_node_id(self):
+ """
+ Getter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ return self.__node_id
+
+ def _set_node_id(self, v, load=False):
+ """
+ Setter method for node_id, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/node_id (te-node-id)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_node_id is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_node_id() directly.
+
+ YANG Description: The identifier of a node in the TE topology.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """node_id must be of a type compatible with te-node-id""",
+ 'defined-type': "ietf-te-topology:te-node-id",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)""",
+ })
+
+ self.__node_id = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_node_id(self):
+ self.__node_id = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_dict={'pattern': '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'}), is_leaf=True, yang_name="node-id", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-node-id', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+
+ def _get_direction(self):
+ """
+ Getter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+
+ YANG Description: Link route object direction.
+ """
+ return self.__direction
+
+ def _set_direction(self, v, load=False):
+ """
+ Setter method for direction, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/unnumbered_link_hop/direction (te-link-direction)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_direction is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_direction() directly.
+
+ YANG Description: Link route object direction.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """direction must be of a type compatible with te-link-direction""",
+ 'defined-type': "ietf-te-topology:te-link-direction",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)""",
+ })
+
+ self.__direction = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_direction(self):
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'incoming': {}, 'outgoing': {}},), default=six.text_type("outgoing"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-link-direction', is_config=True)
+
+ link_tp_id = __builtin__.property(_get_link_tp_id, _set_link_tp_id)
+ node_id = __builtin__.property(_get_node_id, _set_node_id)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+ direction = __builtin__.property(_get_direction, _set_direction)
+
+ __choices__ = {'type': {'unnumbered-link-hop': ['link_tp_id', 'node_id', 'hop_type', 'direction']}}
+ _pyangbind_elements = OrderedDict([('link_tp_id', link_tp_id), ('node_id', node_id), ('hop_type', hop_type), ('direction', direction), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..f0ae851c18fa662017979f10868a8a46fb0f2432
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel_termination_points(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/tunnel-termination-points. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TTPs desired for this link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__source','__destination',)
+
+ _yang_name = 'tunnel-termination-points'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'tunnel-termination-points']
+
+ def _get_source(self):
+ """
+ Getter method for source, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points/source (binary)
+
+ YANG Description: Source TTP identifier.
+ """
+ return self.__source
+
+ def _set_source(self, v, load=False):
+ """
+ Setter method for source, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points/source (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_source is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_source() directly.
+
+ YANG Description: Source TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """source must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)""",
+ })
+
+ self.__source = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_source(self):
+ self.__source = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="source", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+
+ def _get_destination(self):
+ """
+ Getter method for destination, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points/destination (binary)
+
+ YANG Description: Destination TTP identifier.
+ """
+ return self.__destination
+
+ def _set_destination(self, v, load=False):
+ """
+ Setter method for destination, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points/destination (binary)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_destination is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_destination() directly.
+
+ YANG Description: Destination TTP identifier.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """destination must be of a type compatible with binary""",
+ 'defined-type': "binary",
+ 'generated-type': """YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)""",
+ })
+
+ self.__destination = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_destination(self):
+ self.__destination = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="destination", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='binary', is_config=True)
+
+ source = __builtin__.property(_get_source, _set_source)
+ destination = __builtin__.property(_get_destination, _set_destination)
+
+
+ _pyangbind_elements = OrderedDict([('source', source), ('destination', destination), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b49e97083a810c0ea140cb33745f326de12b0151
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/__init__.py
@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import tunnel
+class tunnels(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/tunnels. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Underlay TE tunnels supporting this TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__sharing','__tunnel',)
+
+ _yang_name = 'tunnels'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'tunnels']
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+This leaf is the default option for all TE tunnels
+and may be overridden by the per-TE-tunnel value.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, default=YANGBool("true"), is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+
+ def _get_tunnel(self):
+ """
+ Getter method for tunnel, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel (list)
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ return self.__tunnel
+
+ def _set_tunnel(self, v, load=False):
+ """
+ Setter method for tunnel, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel() directly.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__tunnel = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel(self):
+ self.__tunnel = YANGDynClass(base=YANGListType("tunnel_name",tunnel.tunnel, yang_name="tunnel", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='tunnel-name', extensions=None), is_container='list', yang_name="tunnel", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ sharing = __builtin__.property(_get_sharing, _set_sharing)
+ tunnel = __builtin__.property(_get_tunnel, _set_tunnel)
+
+
+ _pyangbind_elements = OrderedDict([('sharing', sharing), ('tunnel', tunnel), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/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..bc8bc8ecbd670ac03bab9bba8daf41436e1924ab
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel/__init__.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class tunnel(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/local-link-connectivity/underlay/tunnels/tunnel. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Zero, one, or more underlay TE tunnels that support this
+TE link.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__tunnel_name','__sharing',)
+
+ _yang_name = 'tunnel'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'local-link-connectivity', 'underlay', 'tunnels', 'tunnel']
+
+ def _get_tunnel_name(self):
+ """
+ Getter method for tunnel_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel/tunnel_name (string)
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ return self.__tunnel_name
+
+ def _set_tunnel_name(self, v, load=False):
+ """
+ Setter method for tunnel_name, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel/tunnel_name (string)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tunnel_name is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tunnel_name() directly.
+
+ YANG Description: A tunnel name uniquely identifies an underlay TE tunnel,
+used together with the 'source-node' value for this
+link.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tunnel_name must be of a type compatible with string""",
+ 'defined-type': "string",
+ 'generated-type': """YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)""",
+ })
+
+ self.__tunnel_name = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tunnel_name(self):
+ self.__tunnel_name = YANGDynClass(base=six.text_type, is_leaf=True, yang_name="tunnel-name", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='string', is_config=True)
+
+
+ def _get_sharing(self):
+ """
+ Getter method for sharing, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel/sharing (boolean)
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ return self.__sharing
+
+ def _set_sharing(self, v, load=False):
+ """
+ Setter method for sharing, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel/sharing (boolean)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_sharing is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_sharing() directly.
+
+ YANG Description: 'true' if the underlay tunnel can be shared with other
+TE links;
+'false' if the underlay tunnel is dedicated to this
+TE link.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """sharing must be of a type compatible with boolean""",
+ 'defined-type': "boolean",
+ 'generated-type': """YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)""",
+ })
+
+ self.__sharing = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_sharing(self):
+ self.__sharing = YANGDynClass(base=YANGBool, is_leaf=True, yang_name="sharing", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='boolean', is_config=True)
+
+ tunnel_name = __builtin__.property(_get_tunnel_name, _set_tunnel_name)
+ sharing = __builtin__.property(_get_sharing, _set_sharing)
+
+
+ _pyangbind_elements = OrderedDict([('tunnel_name', tunnel_name), ('sharing', sharing), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ed824918759d90f3e7cfbaa93f66622c3698763
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/__init__.py
@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import optimization_metric
+from . import tiebreakers
+from . import objective_function
+class optimizations(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/optimizations. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__optimization_metric','__tiebreakers','__objective_function',)
+
+ _yang_name = 'optimizations'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'optimizations']
+
+ def _get_optimization_metric(self):
+ """
+ Getter method for optimization_metric, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric (list)
+
+ YANG Description: TE path metric type.
+ """
+ return self.__optimization_metric
+
+ def _set_optimization_metric(self, v, load=False):
+ """
+ Setter method for optimization_metric, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_optimization_metric is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_optimization_metric() directly.
+
+ YANG Description: TE path metric type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """optimization_metric must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__optimization_metric = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_optimization_metric(self):
+ self.__optimization_metric = YANGDynClass(base=YANGListType("metric_type",optimization_metric.optimization_metric, yang_name="optimization-metric", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='metric-type', extensions=None, choice=False), is_container='list', yang_name="optimization-metric", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+
+ def _get_tiebreakers(self):
+ """
+ Getter method for tiebreakers, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/tiebreakers (container)
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ return self.__tiebreakers
+
+ def _set_tiebreakers(self, v, load=False):
+ """
+ Setter method for tiebreakers, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/tiebreakers (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_tiebreakers is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_tiebreakers() directly.
+
+ YANG Description: Container for the list of tiebreakers.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """tiebreakers must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__tiebreakers = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_tiebreakers(self):
+ self.__tiebreakers = YANGDynClass(base=tiebreakers.tiebreakers, is_container='container', yang_name="tiebreakers", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_objective_function(self):
+ """
+ Getter method for objective_function, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/objective_function (container)
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ return self.__objective_function
+
+ def _set_objective_function(self, v, load=False):
+ """
+ Setter method for objective_function, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/objective_function (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function() directly.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__objective_function = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function(self):
+ self.__objective_function = YANGDynClass(base=objective_function.objective_function, is_container='container', yang_name="objective-function", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ optimization_metric = __builtin__.property(_get_optimization_metric, _set_optimization_metric)
+ tiebreakers = __builtin__.property(_get_tiebreakers, _set_tiebreakers)
+ objective_function = __builtin__.property(_get_objective_function, _set_objective_function)
+
+ __choices__ = {'algorithm': {'metric': ['optimization_metric', 'tiebreakers'], 'objective-function': ['objective_function']}}
+ _pyangbind_elements = OrderedDict([('optimization_metric', optimization_metric), ('tiebreakers', tiebreakers), ('objective_function', objective_function), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/objective_function/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/objective_function/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c10569db3b8424d75a3241100ff3348ed909997
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/objective_function/__init__.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class objective_function(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/optimizations/objective-function. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: The objective function container that includes
+attributes to impose when computing a TE path.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__objective_function_type',)
+
+ _yang_name = 'objective-function'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'optimizations', 'objective-function']
+
+ def _get_objective_function_type(self):
+ """
+ Getter method for objective_function_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/objective_function/objective_function_type (identityref)
+
+ YANG Description: Objective function entry.
+ """
+ return self.__objective_function_type
+
+ def _set_objective_function_type(self, v, load=False):
+ """
+ Setter method for objective_function_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/objective_function/objective_function_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_objective_function_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_objective_function_type() directly.
+
+ YANG Description: Objective function entry.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """objective_function_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__objective_function_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_objective_function_type(self):
+ self.__objective_function_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-path': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-maximize-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-agg-bandwidth-consumption': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-load-most-loaded-link': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:of-minimize-cost-path-set': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), default=six.text_type("te-types:of-minimize-cost-path"), is_leaf=True, yang_name="objective-function-type", parent=self, choice=('algorithm', 'objective-function'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+ objective_function_type = __builtin__.property(_get_objective_function_type, _set_objective_function_type)
+
+ __choices__ = {'algorithm': {'objective-function': ['objective_function_type']}}
+ _pyangbind_elements = OrderedDict([('objective_function_type', objective_function_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..abb419890db7c10441efe74dc76a073b4087d58c
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/__init__.py
@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import explicit_route_exclude_objects
+from . import explicit_route_include_objects
+class optimization_metric(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/optimizations/optimization-metric. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: TE path metric type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__metric_type','__weight','__explicit_route_exclude_objects','__explicit_route_include_objects',)
+
+ _yang_name = 'optimization-metric'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'optimizations', 'optimization-metric']
+
+ def _get_metric_type(self):
+ """
+ Getter method for metric_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/metric_type (identityref)
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ return self.__metric_type
+
+ def _set_metric_type(self, v, load=False):
+ """
+ Setter method for metric_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/metric_type (identityref)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_metric_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_metric_type() directly.
+
+ YANG Description: Identifies the 'metric-type' that the path computation
+process uses for optimization.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """metric_type must be of a type compatible with identityref""",
+ 'defined-type': "ietf-te-topology:identityref",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)""",
+ })
+
+ self.__metric_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_metric_type(self):
+ self.__metric_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-te': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-igp': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-hop': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-average': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-delay-minimum': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-residual-bandwidth': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-includes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'ietf-te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}, 'te-types:path-metric-optimize-excludes': {'@module': 'ietf-te-types', '@namespace': 'urn:ietf:params:xml:ns:yang:ietf-te-types'}},), is_leaf=True, yang_name="metric-type", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='identityref', is_config=True)
+
+
+ def _get_weight(self):
+ """
+ Getter method for weight, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/weight (uint8)
+
+ YANG Description: TE path metric normalization weight.
+ """
+ return self.__weight
+
+ def _set_weight(self, v, load=False):
+ """
+ Setter method for weight, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/weight (uint8)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_weight is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_weight() directly.
+
+ YANG Description: TE path metric normalization weight.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """weight must be of a type compatible with uint8""",
+ 'defined-type': "uint8",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)""",
+ })
+
+ self.__weight = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_weight(self):
+ self.__weight = YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), default=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8)(1), is_leaf=True, yang_name="weight", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint8', is_config=True)
+
+
+ def _get_explicit_route_exclude_objects(self):
+ """
+ Getter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ return self.__explicit_route_exclude_objects
+
+ def _set_explicit_route_exclude_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_exclude_objects, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_exclude_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_exclude_objects() directly.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_exclude_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__explicit_route_exclude_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_exclude_objects(self):
+ self.__explicit_route_exclude_objects = YANGDynClass(base=explicit_route_exclude_objects.explicit_route_exclude_objects, is_container='container', yang_name="explicit-route-exclude-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_explicit_route_include_objects(self):
+ """
+ Getter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_include_objects (container)
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ return self.__explicit_route_include_objects
+
+ def _set_explicit_route_include_objects(self, v, load=False):
+ """
+ Setter method for explicit_route_include_objects, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_include_objects (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_explicit_route_include_objects is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_explicit_route_include_objects() directly.
+
+ YANG Description: Container for the 'include route' object list.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """explicit_route_include_objects must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__explicit_route_include_objects = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_explicit_route_include_objects(self):
+ self.__explicit_route_include_objects = YANGDynClass(base=explicit_route_include_objects.explicit_route_include_objects, is_container='container', yang_name="explicit-route-include-objects", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ metric_type = __builtin__.property(_get_metric_type, _set_metric_type)
+ weight = __builtin__.property(_get_weight, _set_weight)
+ explicit_route_exclude_objects = __builtin__.property(_get_explicit_route_exclude_objects, _set_explicit_route_exclude_objects)
+ explicit_route_include_objects = __builtin__.property(_get_explicit_route_include_objects, _set_explicit_route_include_objects)
+
+ __choices__ = {'algorithm': {'metric': ['metric_type', 'weight', 'explicit_route_exclude_objects', 'explicit_route_include_objects']}}
+ _pyangbind_elements = OrderedDict([('metric_type', metric_type), ('weight', weight), ('explicit_route_exclude_objects', explicit_route_exclude_objects), ('explicit_route_include_objects', explicit_route_include_objects), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3831dbff9b1144fa1415a445b89031271bd42649
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import route_object_exclude_object
+class explicit_route_exclude_objects(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/optimizations/optimization-metric/explicit-route-exclude-objects. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container for the 'exclude route' object list.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__route_object_exclude_object',)
+
+ _yang_name = 'explicit-route-exclude-objects'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects']
+
+ def _get_route_object_exclude_object(self):
+ """
+ Getter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ return self.__route_object_exclude_object
+
+ def _set_route_object_exclude_object(self, v, load=False):
+ """
+ Setter method for route_object_exclude_object, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object (list)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_route_object_exclude_object is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_route_object_exclude_object() directly.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """route_object_exclude_object must be of a type compatible with list""",
+ 'defined-type': "list",
+ 'generated-type': """YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)""",
+ })
+
+ self.__route_object_exclude_object = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_route_object_exclude_object(self):
+ self.__route_object_exclude_object = YANGDynClass(base=YANGListType("index",route_object_exclude_object.route_object_exclude_object, yang_name="route-object-exclude-object", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper, yang_keys='index', extensions=None, choice=('algorithm', 'metric')), is_container='list', yang_name="route-object-exclude-object", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='list', is_config=True)
+
+ route_object_exclude_object = __builtin__.property(_get_route_object_exclude_object, _set_route_object_exclude_object)
+
+ __choices__ = {'algorithm': {'metric': ['route_object_exclude_object']}}
+ _pyangbind_elements = OrderedDict([('route_object_exclude_object', route_object_exclude_object), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dea360b243ea8087c4f2a0945c9a230d073d9ecd
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py
@@ -0,0 +1,365 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import numbered_node_hop
+from . import numbered_link_hop
+from . import unnumbered_link_hop
+from . import as_number_hop
+from . import label_hop
+from . import srlg
+class route_object_exclude_object(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: List of Explicit Route Objects to be excluded in the
+path computation.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__index','__numbered_node_hop','__numbered_link_hop','__unnumbered_link_hop','__as_number_hop','__label_hop','__srlg',)
+
+ _yang_name = 'route-object-exclude-object'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object']
+
+ def _get_index(self):
+ """
+ Getter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ return self.__index
+
+ def _set_index(self, v, load=False):
+ """
+ Setter method for index, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/index (uint32)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_index is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_index() directly.
+
+ YANG Description: Route object entry index. The index is used to
+identify an entry in the list. The order of entries
+is defined by the user without relying on key values.
+ """
+ parent = getattr(self, "_parent", None)
+ if parent is not None and load is False:
+ raise AttributeError("Cannot set keys directly when" +
+ " within an instantiated list")
+
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """index must be of a type compatible with uint32""",
+ 'defined-type': "uint32",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)""",
+ })
+
+ self.__index = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_index(self):
+ self.__index = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="index", parent=self, choice=('algorithm', 'metric'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='uint32', is_config=True)
+
+
+ def _get_numbered_node_hop(self):
+ """
+ Getter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+
+ YANG Description: Numbered node route hop.
+ """
+ return self.__numbered_node_hop
+
+ def _set_numbered_node_hop(self, v, load=False):
+ """
+ Setter method for numbered_node_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_node_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_node_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_node_hop() directly.
+
+ YANG Description: Numbered node route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_node_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_node_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_node_hop(self):
+ self.__numbered_node_hop = YANGDynClass(base=numbered_node_hop.numbered_node_hop, is_container='container', yang_name="numbered-node-hop", parent=self, choice=('type', 'numbered-node-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_numbered_link_hop(self):
+ """
+ Getter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ return self.__numbered_link_hop
+
+ def _set_numbered_link_hop(self, v, load=False):
+ """
+ Setter method for numbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/numbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_numbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_numbered_link_hop() directly.
+
+ YANG Description: Numbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """numbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__numbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_numbered_link_hop(self):
+ self.__numbered_link_hop = YANGDynClass(base=numbered_link_hop.numbered_link_hop, is_container='container', yang_name="numbered-link-hop", parent=self, choice=('type', 'numbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_unnumbered_link_hop(self):
+ """
+ Getter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ return self.__unnumbered_link_hop
+
+ def _set_unnumbered_link_hop(self, v, load=False):
+ """
+ Setter method for unnumbered_link_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/unnumbered_link_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_unnumbered_link_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_unnumbered_link_hop() directly.
+
+ YANG Description: Unnumbered link explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """unnumbered_link_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__unnumbered_link_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_unnumbered_link_hop(self):
+ self.__unnumbered_link_hop = YANGDynClass(base=unnumbered_link_hop.unnumbered_link_hop, is_container='container', yang_name="unnumbered-link-hop", parent=self, choice=('type', 'unnumbered-link-hop'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_as_number_hop(self):
+ """
+ Getter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+
+ YANG Description: AS explicit route hop.
+ """
+ return self.__as_number_hop
+
+ def _set_as_number_hop(self, v, load=False):
+ """
+ Setter method for as_number_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number_hop() directly.
+
+ YANG Description: AS explicit route hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__as_number_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number_hop(self):
+ self.__as_number_hop = YANGDynClass(base=as_number_hop.as_number_hop, is_container='container', yang_name="as-number-hop", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_label_hop(self):
+ """
+ Getter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+
+ YANG Description: Label hop type.
+ """
+ return self.__label_hop
+
+ def _set_label_hop(self, v, load=False):
+ """
+ Setter method for label_hop, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_label_hop is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_label_hop() directly.
+
+ YANG Description: Label hop type.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """label_hop must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__label_hop = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_label_hop(self):
+ self.__label_hop = YANGDynClass(base=label_hop.label_hop, is_container='container', yang_name="label-hop", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+
+ def _get_srlg(self):
+ """
+ Getter method for srlg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+
+ YANG Description: SRLG container.
+ """
+ return self.__srlg
+
+ def _set_srlg(self, v, load=False):
+ """
+ Setter method for srlg, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/srlg (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_srlg is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_srlg() directly.
+
+ YANG Description: SRLG container.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """srlg must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__srlg = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_srlg(self):
+ self.__srlg = YANGDynClass(base=srlg.srlg, is_container='container', yang_name="srlg", parent=self, choice=('type', 'srlg'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ index = __builtin__.property(_get_index, _set_index)
+ numbered_node_hop = __builtin__.property(_get_numbered_node_hop, _set_numbered_node_hop)
+ numbered_link_hop = __builtin__.property(_get_numbered_link_hop, _set_numbered_link_hop)
+ unnumbered_link_hop = __builtin__.property(_get_unnumbered_link_hop, _set_unnumbered_link_hop)
+ as_number_hop = __builtin__.property(_get_as_number_hop, _set_as_number_hop)
+ label_hop = __builtin__.property(_get_label_hop, _set_label_hop)
+ srlg = __builtin__.property(_get_srlg, _set_srlg)
+
+ __choices__ = {'algorithm': {'metric': ['index']}, 'type': {'numbered-node-hop': ['numbered_node_hop'], 'numbered-link-hop': ['numbered_link_hop'], 'unnumbered-link-hop': ['unnumbered_link_hop'], 'as-number': ['as_number_hop'], 'label': ['label_hop'], 'srlg': ['srlg']}}
+ _pyangbind_elements = OrderedDict([('index', index), ('numbered_node_hop', numbered_node_hop), ('numbered_link_hop', numbered_link_hop), ('unnumbered_link_hop', unnumbered_link_hop), ('as_number_hop', as_number_hop), ('label_hop', label_hop), ('srlg', srlg), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2450591ff591b28c8a20d81e919adb39fff1e79
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/__init__.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+class as_number_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/as-number-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: AS explicit route hop.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__as_number','__hop_type',)
+
+ _yang_name = 'as-number-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'as-number-hop']
+
+ def _get_as_number(self):
+ """
+ Getter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ return self.__as_number
+
+ def _set_as_number(self, v, load=False):
+ """
+ Setter method for as_number, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/as_number (inet:as-number)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_as_number is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_as_number() directly.
+
+ YANG Description: The Autonomous System (AS) number.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """as_number must be of a type compatible with inet:as-number""",
+ 'defined-type': "inet:as-number",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)""",
+ })
+
+ self.__as_number = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_as_number(self):
+ self.__as_number = YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name="as-number", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='inet:as-number', is_config=True)
+
+
+ def _get_hop_type(self):
+ """
+ Getter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+
+ YANG Description: Strict or loose hop.
+ """
+ return self.__hop_type
+
+ def _set_hop_type(self, v, load=False):
+ """
+ Setter method for hop_type, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/as_number_hop/hop_type (te-hop-type)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_hop_type is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_hop_type() directly.
+
+ YANG Description: Strict or loose hop.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """hop_type must be of a type compatible with te-hop-type""",
+ 'defined-type': "ietf-te-topology:te-hop-type",
+ 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)""",
+ })
+
+ self.__hop_type = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_hop_type(self):
+ self.__hop_type = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'loose': {}, 'strict': {}},), default=six.text_type("strict"), is_leaf=True, yang_name="hop-type", parent=self, choice=('type', 'as-number'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-hop-type', is_config=True)
+
+ as_number = __builtin__.property(_get_as_number, _set_as_number)
+ hop_type = __builtin__.property(_get_hop_type, _set_hop_type)
+
+ __choices__ = {'type': {'as-number': ['as_number', 'hop_type']}}
+ _pyangbind_elements = OrderedDict([('as_number', as_number), ('hop_type', hop_type), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..05755c89d8c3b35e5d79a27360663653f365d31d
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/__init__.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import te_label
+class label_hop(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Label hop type.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__te_label',)
+
+ _yang_name = 'label-hop'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >1 argument")
+ all_attr = True
+ for e in self._pyangbind_elements:
+ if not hasattr(args[0], e):
+ all_attr = False
+ break
+ if not all_attr:
+ raise ValueError("Supplied object did not have the correct attributes")
+ for e in self._pyangbind_elements:
+ nobj = getattr(args[0], e)
+ if nobj._changed() is False:
+ continue
+ setmethod = getattr(self, "_set_%s" % e)
+ if load is None:
+ setmethod(getattr(args[0], e))
+ else:
+ setmethod(getattr(args[0], e), load=load)
+
+ def _path(self):
+ if hasattr(self, "_parent"):
+ return self._parent._path()+[self._yang_name]
+ else:
+ return ['networks', 'network', 'node', 'te', 'tunnel-termination-point', 'local-link-connectivities', 'optimizations', 'optimization-metric', 'explicit-route-exclude-objects', 'route-object-exclude-object', 'label-hop']
+
+ def _get_te_label(self):
+ """
+ Getter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ return self.__te_label
+
+ def _set_te_label(self, v, load=False):
+ """
+ Setter method for te_label, mapped from YANG variable /networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label (container)
+ If this variable is read-only (config: false) in the
+ source YANG file, then _set_te_label is considered as a private
+ method. Backends looking to populate this variable should
+ do so via calling thisObj._set_te_label() directly.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ if hasattr(v, "_utype"):
+ v = v._utype(v)
+ try:
+ t = YANGDynClass(v,base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+ except (TypeError, ValueError):
+ raise ValueError({
+ 'error-string': """te_label must be of a type compatible with container""",
+ 'defined-type': "container",
+ 'generated-type': """YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)""",
+ })
+
+ self.__te_label = t
+ if hasattr(self, '_set'):
+ self._set()
+
+ def _unset_te_label(self):
+ self.__te_label = YANGDynClass(base=te_label.te_label, is_container='container', yang_name="te-label", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='container', is_config=True)
+
+ te_label = __builtin__.property(_get_te_label, _set_te_label)
+
+ __choices__ = {'type': {'label': ['te_label']}}
+ _pyangbind_elements = OrderedDict([('te_label', te_label), ])
+
+
diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..aaf8055717a002732b93666eb0ca309f3aba8f35
--- /dev/null
+++ b/src/nbi/service/rest_server/nbi_plugins/ietf_network/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/label_hop/te_label/__init__.py
@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from operator import attrgetter
+from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType
+from pyangbind.lib.yangtypes import RestrictedClassType
+from pyangbind.lib.yangtypes import TypedListType
+from pyangbind.lib.yangtypes import YANGBool
+from pyangbind.lib.yangtypes import YANGListType
+from pyangbind.lib.yangtypes import YANGDynClass
+from pyangbind.lib.yangtypes import ReferenceType
+from pyangbind.lib.yangtypes import YANGBinary
+from pyangbind.lib.yangtypes import YANGBitsType
+from pyangbind.lib.base import PybindBase
+from collections import OrderedDict
+from decimal import Decimal
+import six
+
+# PY3 support of some PY2 keywords (needs improved)
+if six.PY3:
+ import builtins as __builtin__
+ long = int
+elif six.PY2:
+ import __builtin__
+
+from . import otn
+class te_label(PybindBase):
+ """
+ This class was auto-generated by the PythonClass plugin for PYANG
+ from YANG module ietf-network - based on the path /networks/network/node/te/tunnel-termination-point/local-link-connectivities/optimizations/optimization-metric/explicit-route-exclude-objects/route-object-exclude-object/label-hop/te-label. Each member element of
+ the container is represented as a class variable - with a specific
+ YANG type.
+
+ YANG Description: Container that specifies the TE label. The choices can
+be augmented for specific data-plane technologies.
+ """
+ __slots__ = ('_path_helper', '_extmethods', '__generic','__otn','__vlanid','__direction',)
+
+ _yang_name = 'te-label'
+ _yang_namespace = 'urn:ietf:params:xml:ns:yang:ietf-network'
+
+ _pybind_generated_by = 'container'
+
+ def __init__(self, *args, **kwargs):
+
+ self._path_helper = False
+
+ self._extmethods = False
+ self.__generic = YANGDynClass(base=YANGBinary, is_leaf=True, yang_name="generic", parent=self, choice=('technology', 'generic'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='rt-types:generalized-label', is_config=True)
+ self.__otn = YANGDynClass(base=otn.otn, is_container='container', yang_name="otn", parent=self, choice=('technology', 'otn'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='urn:ietf:params:xml:ns:yang:ietf-otn-topology', defining_module='ietf-otn-topology', yang_type='container', is_config=True)
+ self.__vlanid = YANGDynClass(base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), restriction_dict={'range': ['1..4094']}), is_leaf=True, yang_name="vlanid", parent=self, choice=('technology', 'eth'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-eth-te-topology', defining_module='ietf-eth-te-topology', yang_type='etht-types:vlanid', is_config=True)
+ self.__direction = YANGDynClass(base=RestrictedClassType(base_type=six.text_type, restriction_type="dict_key", restriction_arg={'forward': {}, 'reverse': {}},), default=six.text_type("forward"), is_leaf=True, yang_name="direction", parent=self, choice=('type', 'label'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:ietf:params:xml:ns:yang:ietf-te-topology', defining_module='ietf-te-topology', yang_type='te-label-direction', is_config=True)
+
+ load = kwargs.pop("load", None)
+ if args:
+ if len(args) > 1:
+ raise TypeError("cannot create a YANG container with >